Developer CD Series 1994 June: Reference Library/Dev.CD Jun 94.toast/Periodicals/develop/develop Issue 15/develop 15 code/3D Interface/Demo3D/U3DDrawing.cp

Text File | 1993-06-02 | 116.4 KB | 4,048 lines | [TEXT/MPS ]

/*
    File:        U3DDrawing.cp

    Contains:    Adorners, classes, etc for 3D drawing effects

    Written by:    Jamie Osborne, Robin Mair, Faulkner White, Henri Lamiraux

    Copyright:    © 1992-1993 by Apple Computer, Inc.

*/

/*
    Some notes:
            1.  This code makes your controls non-internationalized.  If you wish
                to make the controls draw with the correct system orientation
                (e.g. right to left for Hebrew), you need to check the gEnvironment
                variable and setup your drawing rects correctly.  The next Develop
                CD should have a version of this code with
                internationalization supported.
            2.  This code IS compatible with non-Color Quickdraw machines.
            3.    On slower machines (anything slower than an '030), this code will
                be slow.  You should take this into account if you use this library
                in your application.  Test it out on a slower machine to see if
                it is still fast enough for your needs.  If it IS too slow, there
                are many opportunities in the code for optimization.  One example
                is removing some of the CGraphicsState objects from some of the
                routines and replacing them with CPenNormal();
            4.  If you have any questions about the code, please direct them to
                Jamie Osborne (AppleLink: JWO; Internet: [e-mail]).
*/

#ifndef __QUICKDRAW__
    #include <Quickdraw.h>
#endif

#ifndef __RESOURCES__
    #include <Resources.h>
#endif

#ifndef __GESTALTEQU__
    #include <GestaltEqu.h>
#endif

#include "U3DDrawing.h"

//--------------------------------------------------------------------------------------
// InitU3DDrawing        Include this routine in your initialization function
//--------------------------------------------------------------------------------------

#pragma segment AInit
pascal void InitU3DDrawing()
{
    macroDontDeadStrip(TGrayBackgroundAdorner);
    macroDontDeadStrip(TWhiteBackgroundAdorner);
    macroDontDeadStrip(T3DGrayBackgroundAdorner);
    macroDontDeadStrip(T3DFrameAdorner);
    macroDontDeadStrip(T3DLineTopAdorner);
    macroDontDeadStrip(T3DLineBottomAdorner);
    macroDontDeadStrip(T3DLineRightAdorner);
    macroDontDeadStrip(T3DLineLeftAdorner);

    macroDontDeadStrip(T3DCheckBox);
    macroDontDeadStrip(T3DRadio);
    macroDontDeadStrip(T3DButton);

    macroDontDeadStrip(T3DIconAdorner);
    macroDontDeadStrip(TIconSuite);
    macroDontDeadStrip(T3DIconButton);
}

//====================================================================================
//    •••••••••••••••••••••••••••• 3D Utility Classes •••••••••••••••••••••••••••••••••••
//====================================================================================

//======================================================================================
//    CLASS: CGraphicsState
//======================================================================================
//
//        This class is used to save and restore the current Quickdraw graphics state.
//    Create one of these objects at the beginning of a drawing method then use it to
//    save and restore the state of the graphics before and after your drawing.  When
//    one of these objects is created the Constructor saves off the current settings
// for the fore and background colors, the pen state and the current textstyle.  It
//    also does a PenNormal() call in preparation for drawing.  The destructor will just
// reverse this process.  Two methods are provided that allow an explicit Save() and
//    Restore() that mimic the constructor and destructor.  These method can be called
// if you want to reuse the same object during drawing.  The destructor will use the
//    last values saved.

//--------------------------------------------------------------------------------------
// CGraphicsState::CGraphicsState        ---<<• CONSTRUCTOR •>>---
//--------------------------------------------------------------------------------------
//
//        Initialize the instance variables of the object by saving the current state
// of some of the current port settings.
//
#pragma segment AUtils

CGraphicsState::CGraphicsState ()
{
     // • First save off the foreground and background colors and the penstate
    GetIfColor ( fSaveForeColor );
    GetIfBkColor ( fSaveBackColor );
    GetPenState ( fSavePenState );
    CPenNormal ();

    // • Now save off the current port's textstyle information
    GetPortTextStyle ( fSaveTextStyle );

} // CGraphicsState::CGraphicsState

//--------------------------------------------------------------------------------------
// CGraphicsState::~CGraphicsState        ---<<• DESTRUCTOR •>>---
//--------------------------------------------------------------------------------------
//
//        The destructor simply restores the last Save() state when it is called
//
#pragma segment AUtils

CGraphicsState::~CGraphicsState ()
{
    // • Restore the foreground and background colors and the penstate
    SetIfColor ( fSaveForeColor );
    SetIfBkColor ( fSaveBackColor );
    SetPenState ( fSavePenState );

    // • Now restore the textstyle of the current port
    SetPortTextStyle ( fSaveTextStyle );

} // CGraphicsState::~CGraphicsState

//--------------------------------------------------------------------------------------
// CGraphicsState::Save
//--------------------------------------------------------------------------------------
//
//        Save off the current graphics state so that we can restore it again
// after we are done with our drawing.  Also calls PenNormal () to set the
//    pen to the Quickdraw defaults.
//
#pragma segment AUtils

void CGraphicsState::Save ()
{
     // • First save off the foreground and background colors and the penstate
    GetIfColor ( fSaveForeColor );
    GetIfBkColor ( fSaveBackColor );
    GetPenState ( fSavePenState );
    CPenNormal ();

    // • Now save off the current port's textstyle information
    GetPortTextStyle ( fSaveTextStyle );

} // CGraphicsState::Save

//--------------------------------------------------------------------------------------
// CGraphicsState::Restore
//--------------------------------------------------------------------------------------
//
//        Restores the graphics state, this is typically called after doing some drawing
// and after we have created an instance of this class or called the Save () method.
//
#pragma segment AUtils

void CGraphicsState::Restore ()
{

    // • Restore the foreground and background colors and the penstate
    SetIfColor ( fSaveForeColor );
    SetIfBkColor ( fSaveBackColor );
    SetPenState ( fSavePenState );

    // • Now restore the textstyle of the current port
    SetPortTextStyle ( fSaveTextStyle );

} // CGraphicsState::Restore


//======================================================================================
// Class CDrawPerDevice
//======================================================================================
//

//--------------------------------------------------------------------------------------
// CDrawPerDevice::CDrawPerDevice        ---<<• CONSTRUCTOR •>>---
//--------------------------------------------------------------------------------------
#pragma segment AUtils

CDrawPerDevice::CDrawPerDevice()
{
    //    • Initialize our instance variables
    fSaveClip = NULL;
    fGDHandle = NULL;

} // CDrawPerDevice::CDrawPerDevice

//--------------------------------------------------------------------------------------
// CDrawPerDevice::CDrawPerDevice        ---<<• CONSTRUCTOR •>>---
//--------------------------------------------------------------------------------------
#pragma segment AUtils

CDrawPerDevice::CDrawPerDevice ( const CRect& area )
{

    //    • Initialize our fields
    fSaveClip = NULL;
    fGDHandle = NULL;

    //    • Save off the area passed in and convert it to global coordinates
    fGlobalArea = area;
    LocalToGlobal ( fGlobalArea[topLeft] );
    LocalToGlobal ( fGlobalArea[botRight] );


//    Remember the View port info
    fFocus.itsViewPortInfo.clip = MakeNewRgn();
    GetFocus(fFocus);

    fSaveClip = fFocus.itsViewPortInfo.clip;

//    Set a placeholder for non Color QD drawing
    fDoneOldQD = FALSE;
} // CDrawPerDevice::CDrawPerDevice

//--------------------------------------------------------------------------------------
// CDrawPerDevice::~CDrawPerDevice        ---<<• DESTRUCTOR •>>---
//--------------------------------------------------------------------------------------
#pragma segment AUtils

CDrawPerDevice::~CDrawPerDevice()
{
//    Restore the port information
    SetFocus(fFocus);

//    • If we have a saved clip then make sure that we displose of the region
    fFocus.itsViewPortInfo.clip = DisposeIfRgnHandle(fFocus.itsViewPortInfo.clip);

} // CDrawPerDevice::~CDrawPerDevice

//--------------------------------------------------------------------------------------
// CDrawPerDevice::SetDrawingArea
//--------------------------------------------------------------------------------------
//
//        This does the same thing as the constructor and can be used to reset the drawing
//    area at anytime
//
#pragma segment AUtils

pascal void CDrawPerDevice::SetDrawingArea ( const CRect& area )
{
    //    • Save off the area passed in and convert it to global coordinates
    fGlobalArea = area;
    LocalToGlobal ( fGlobalArea[topLeft] );
    LocalToGlobal ( fGlobalArea[botRight] );

    //    • Get a handle to the first device in the device list
    fGDHandle = GetDeviceList ();

//    Remember the View port info
    fFocus.itsViewPortInfo.clip = MakeNewRgn();
    GetFocus(fFocus);

    fSaveClip = fFocus.itsViewPortInfo.clip;

} // CDrawPerDevice::SetDrawingArea

//--------------------------------------------------------------------------------------
// CDrawPerDevice::NextDevice
//--------------------------------------------------------------------------------------
//
//        This is the method that is called during the drawing process.  What it does is
//    cycle through each of the devices in the device list, returning the pixel size for
//    the device, it also sets the clipping to the portion of the drawing area that is
// in need of drawing on the current device

#pragma segment AUtils

pascal Boolean CDrawPerDevice::NextDevice ( short& pixelSize )
{

    Boolean foundActiveScreen = FALSE;
    CRect    bounds;
    CRect area;

//    Go ye not into this code if ye have not Color Quickdraw
    if (!gConfiguration.hasColorQD)
    {
        pixelSize = 1;
        foundActiveScreen = !fDoneOldQD;
        fDoneOldQD = !fDoneOldQD;
        return foundActiveScreen;
    }

    //    • We will iterate over the device list while there are devices.  As we do this
    //    are returning the pixel size of the current device and setting the clipping to
    //    the area of that device that is in need of redrawing

  if (fGDHandle == NULL)
    fGDHandle = GetDeviceList();
  else
    fGDHandle = GetNextDevice(fGDHandle);

    while ((fGDHandle != NULL) && (foundActiveScreen == FALSE))
           if (TestDeviceAttribute(fGDHandle, screenDevice) &&
               TestDeviceAttribute(fGDHandle, screenActive))
        {
            foundActiveScreen = TRUE;
            pixelSize = (*(*fGDHandle)->gdPMap)->pixelSize;

            //    • Get the bounds of the current device
            bounds = (*fGDHandle)->gdRect;
            if ( SectRect ( bounds, fGlobalArea, area ) )
            {
                //    • Convert the overlapping area to local coordinates
                GlobalToLocal ( area[topLeft] );
                GlobalToLocal ( area[botRight] );

                //    • Create a temporary region and convert the overlapped area to a region
                CTemporaryRegion    tempRgn;
                RectRgn ( tempRgn, area );

                //    • Set the temporary region to the intersection between the area and the
                // saved clipping region
                SectRgn ( tempRgn, fSaveClip, tempRgn );
                //  Clip to the visregion,too
                SectRgn(tempRgn, qd.thePort->visRgn, tempRgn);

                //    • Set the clip to the overlap
                SetClip ( tempRgn );

            }
            else
            {
                foundActiveScreen = FALSE;
                fGDHandle = GetNextDevice(fGDHandle);
            }
        }
        else
            fGDHandle = GetNextDevice(fGDHandle);

  return foundActiveScreen;

} // CDrawPerDevice::NextDevice


//======================================================================================
// CPenNormal    - a color version of PenNormal()
//======================================================================================
#pragma segment AUtils

pascal void CPenNormal()
{
    RGBForeColor(gRGBBlack);
    RGBBackColor(gRGBWhite);
    PenNormal();

} // CPenNormal



//====================================================================================
//    •••••••••••••••••••••••••••• 3D TView Adorners •••••••••••••••••••••••••••••••••••
//====================================================================================

//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void TWhiteBackgroundAdorner::Initialize()
{
    inherited::Initialize();
}


//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void TWhiteBackgroundAdorner::IWhiteBackgroundAdorner(Boolean freeOnDeletion)
{

    this->IAdorner(kWhiteBackgroundAdorner,freeOnDeletion);

} // T3DWhiteBackgroundAdorner::I3DWhiteBackgroundAdorner


//--------------------------------------------------------------------------------------------------
#pragma segment A3DRes

pascal void TWhiteBackgroundAdorner::Draw(TView* itsView, const VRect& area)
{

    CRect            qdArea;
    short            pixelSize;
    CGraphicsState     rememberGState;

    itsView->ViewToQDRect(area, qdArea);

    CDrawPerDevice device(qdArea);
    while (device.NextDevice(pixelSize))
    {
//        Only draw us if we are on a non B & W monitor
        if (pixelSize >= 4)
        {
            SetIfBkColor(gRGBWhite);
            EraseRect(qdArea);
        }
    }
} // TWhiteBackgroundAdorner::Draw


//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void TGrayBackgroundAdorner::Initialize()
{
    inherited::Initialize();
}


//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void TGrayBackgroundAdorner::IGrayBackgroundAdorner(Boolean freeOnDeletion)
{

    this->IAdorner(kGrayBackgroundAdorner,freeOnDeletion);

} // T3DGrayBackgroundAdorner::I3DGrayBackgroundAdorner


//--------------------------------------------------------------------------------------------------
#pragma segment A3DRes

pascal void TGrayBackgroundAdorner::Draw(TView* itsView, const VRect& area)
{

    CRect            qdArea;
    short            pixelSize;
    CGraphicsState     rememberGState;

    itsView->ViewToQDRect(area, qdArea);

    CDrawPerDevice device(qdArea);
    while (device.NextDevice(pixelSize))
    {
        if (pixelSize >= 4)
        {
//            Erase because we want our subviews to draw on gray
            SetIfBkColor(kLightGray);
            EraseRect(qdArea);
        }
    }
} // TGrayBackgroundAdorner::Draw


//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void T3DGrayBackgroundAdorner::Initialize()
{
    inherited::Initialize();
}


//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void T3DGrayBackgroundAdorner::I3DGrayBackgroundAdorner(Boolean freeOnDeletion)
{

    this->IGrayBackgroundAdorner(freeOnDeletion);

} // T3DGrayBackgroundAdorner::I3DGrayBackgroundAdorner


//--------------------------------------------------------------------------------------------------
#pragma segment A3DRes

pascal void T3DGrayBackgroundAdorner::Draw(TView* itsView, const VRect& area)
{

    CRect            qdArea, frame;
    VRect            viewRect;
    short            pixelSize;
    CGraphicsState     rememberGState;

//    Erase the background in gray
    inherited:: Draw(itsView,area);

    itsView->ViewToQDRect(area, qdArea);
    itsView->GetAdornExtent(viewRect);
    itsView->ViewToQDRect(viewRect, frame);

    CDrawPerDevice device(qdArea);
    while (device.NextDevice(pixelSize))
    {
//        Only draw on non- B & W
        if (pixelSize >= 4)
        {
            SetIfColor(gRGBWhite);
            MoveTo(frame.right-1, frame.top);
            LineTo(frame.left, frame.top);
            LineTo(frame.left, frame.bottom);

            SetIfColor(kMediumLightGray);
            MoveTo(frame.left+1, frame.bottom-1);
            LineTo(frame.right-1, frame.bottom-1);
            LineTo(frame.right-1, frame.top+1);
        }
    }

} // T3DGrayBackgroundAdorner::Draw


//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void T3DLineTopAdorner::Initialize()
{
    inherited::Initialize();
}


//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void T3DLineTopAdorner::I3DLineTopAdorner(Boolean freeOnDeletion)
{

    this->IAdorner(k3DLineTopAdorner,freeOnDeletion);

} // T3DLineTopAdorner::I3DLineTopAdorner


//--------------------------------------------------------------------------------------------------
#pragma segment A3DRes

pascal void T3DLineTopAdorner::Draw(TView* itsView, const VRect& area)
{

    CRect            qdArea, frame;
    VRect            viewRect;
    short            pixelSize;
    CGraphicsState  rememberGState;

    itsView->ViewToQDRect(area, qdArea);
    itsView->GetAdornExtent(viewRect);
    itsView->ViewToQDRect(viewRect, frame);

    CDrawPerDevice device(qdArea);
    while (device.NextDevice(pixelSize))
    {
//        Draw a gray and white line for non- B & W
        if (pixelSize >= 4)
        {
            SetIfColor(kMediumLightGray);
            MoveTo(frame.left, frame.top);
            LineTo(frame.right, frame.top);

            SetIfColor(gRGBWhite);
            MoveTo(frame.left, frame.top + 1);
            LineTo(frame.right, frame.top + 1);
        }
//        Draw a regular black line
        else
        {

            PenPat(&qd.black);
            MoveTo(frame.left, frame.top);
            LineTo(frame.right, frame.top);
        }
    }

} // T3DLineTopAdorner::Draw


//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void T3DLineBottomAdorner::Initialize()
{
    inherited::Initialize();
}


//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void T3DLineBottomAdorner::I3DLineBottomAdorner(Boolean freeOnDeletion)
{

    this->IAdorner(k3DLineBottomAdorner,freeOnDeletion);

} // T3DLineBottomAdorner::I3DLineBottomAdorner


//--------------------------------------------------------------------------------------------------
#pragma segment A3DRes

pascal void T3DLineBottomAdorner::Draw(TView* itsView, const VRect& area)
{

    CRect            qdArea, frame;
    VRect            viewRect;
    short            pixelSize;
    CGraphicsState  rememberGState;

    itsView->ViewToQDRect(area, qdArea);
    itsView->GetAdornExtent(viewRect);
    itsView->ViewToQDRect(viewRect, frame);

    CDrawPerDevice device(qdArea);
    while (device.NextDevice(pixelSize))
    {
//        Draw a gray and white line for non- B & W
        if (pixelSize >= 4)
        {
            SetIfColor(kMediumLightGray);
            MoveTo(frame.left, frame.bottom - 1);
            LineTo(frame.right, frame.bottom - 1);

            SetIfColor(gRGBWhite);
            MoveTo(frame.left, frame.bottom);
            LineTo(frame.right, frame.bottom);
        }
//        Draw a regular black line
        else
        {

            PenPat(&qd.black);
            MoveTo(frame.left, frame.bottom - 1);
            LineTo(frame.right, frame.bottom - 1);
        }
    }

} // T3DLineBottomAdorner::Draw

//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void T3DLineLeftAdorner::Initialize()
{
    inherited::Initialize();
}


//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void T3DLineLeftAdorner::I3DLineLeftAdorner(Boolean freeOnDeletion)
{

    this->IAdorner(k3DLineLeftAdorner,freeOnDeletion);

} // T3DLineLeftAdorner::I3DLineLeftAdorner


//--------------------------------------------------------------------------------------------------
#pragma segment A3DRes

pascal void T3DLineLeftAdorner::Draw(TView* itsView, const VRect& area)
{

    CRect            qdArea, frame;
    VRect            viewRect;
    short            pixelSize;
    CGraphicsState  rememberGState;

    itsView->ViewToQDRect(area, qdArea);
    itsView->GetAdornExtent(viewRect);
    itsView->ViewToQDRect(viewRect, frame);

    CDrawPerDevice device(qdArea);
    while (device.NextDevice(pixelSize))
    {
//        Draw a gray and white line for non- B & W
        if (pixelSize >= 4)
        {
            SetIfColor(kMediumLightGray);
            MoveTo(frame.left, frame.top);
            LineTo(frame.left, frame.bottom);

            SetIfColor(gRGBWhite);
            MoveTo(frame.left + 1, frame.top);
            LineTo(frame.left + 1, frame.bottom);
        }
//        Draw a regular black line
        else
        {

            PenPat(&qd.black);
            MoveTo(frame.left, frame.top);
            LineTo(frame.left, frame.bottom);
        }
    }

} // T3DLineLeftAdorner::Draw

//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void T3DLineRightAdorner::Initialize()
{
    inherited::Initialize();
}


//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void T3DLineRightAdorner::I3DLineRightAdorner(Boolean freeOnDeletion)
{

    this->IAdorner(k3DLineRightAdorner,freeOnDeletion);

} // T3DLineRightAdorner::I3DLineRightAdorner


//--------------------------------------------------------------------------------------------------
#pragma segment A3DRes

pascal void T3DLineRightAdorner::Draw(TView* itsView, const VRect& area)
{

    CRect            qdArea, frame;
    VRect            viewRect;
    short            pixelSize;
    CGraphicsState  rememberGState;

    itsView->ViewToQDRect(area, qdArea);
    itsView->GetAdornExtent(viewRect);
    itsView->ViewToQDRect(viewRect, frame);

    CDrawPerDevice device(qdArea);
    while (device.NextDevice(pixelSize))
    {
//        Draw a gray and white line for non- B & W
        if (pixelSize >= 4)
        {
            SetIfColor(kMediumLightGray);
            MoveTo(frame.right - 1, frame.top);
            LineTo(frame.right -1, frame.bottom);

            SetIfColor(gRGBWhite);
            MoveTo(frame.right, frame.top);
            LineTo(frame.right, frame.bottom);
        }
//        Draw a regular black line
        else
        {

            PenPat(&qd.black);
            MoveTo(frame.right - 1, frame.top);
            LineTo(frame.right - 1, frame.bottom);
        }
    }

} // T3DLineRightAdorner::Draw


//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void T3DFrameAdorner::Initialize()
{
    inherited::Initialize();
}


//--------------------------------------------------------------------------------------------------
#pragma segment A3DOpen

pascal void T3DFrameAdorner::I3DFrameAdorner(Boolean freeOnDeletion)
{

    this->IAdorner(k3DFrameAdorner,freeOnDeletion);

} // T3DFrameAdorner::I3DFrameAdorner


//--------------------------------------------------------------------------------------------------
#pragma segment A3DRes

pascal void T3DFrameAdorner::Draw(TView* itsView, const VRect& area)
{

    CRect            qdArea, frame;
    VRect            viewRect;
    short            pixelSize;
    CGraphicsState  rememberGState;

    itsView->ViewToQDRect(area, qdArea);
    itsView->GetAdornExtent(viewRect);
    itsView->ViewToQDRect(viewRect, frame);

    CDrawPerDevice device(qdArea);
    while (device.NextDevice(pixelSize))
    {
//        Draw a gray and white frame with black outline
        if (pixelSize >= 4) {

            SetIfColor(kMediumLightGray);
            MoveTo(frame.right, frame.top);
            LineTo(frame.left, frame.top);
            LineTo(frame.left, frame.bottom);

            SetIfColor(gRGBWhite);
            MoveTo(frame.left +1, frame.bottom -1);
            LineTo(frame.right -1, frame.bottom -1);
            LineTo(frame.right -1, frame.top + 1);

            SetIfColor(gRGBBlack);
            InsetRect(frame, 1, 1);
            FrameRect(frame);
            InsetRect(frame, -1, -1);
        }
//        Draw a regular frame
        else
        {
            PenPat(&qd.black);
            InsetRect(frame, 1, 1);
            FrameRect(frame);
            InsetRect(frame, -1, -1);
        }
    }

} // T3DFrameAdorner::Draw



//====================================================================================
//    ••••••••••••••••• TControl classes and auxiliary adorners •••••••••••••••••••••••
//====================================================================================

//-------------------------------------------------------------------------------------
// T3DCheckBox::Initialize
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DCheckBox::Initialize ()                // OVERRIDE
{

    inherited::Initialize();

    fBackColor = kLightGray;
    fForeColor = gRGBBlack;
    fDrawBox = VRect(1, 0, 15, 14);        //    A standard check box is 14x14

} // T3DCheckBox::Initialize



//-------------------------------------------------------------------------------------
// T3DCheckBox::DoPostCreate
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DCheckBox::DoPostCreate (TDocument *itsDocument) // OVERRIDE
{
    VRect                    theRect;
    TDrawingEnvironment     *environment;

    inherited::DoPostCreate (itsDocument);

//    If we have a drawing environment, use it for drawing!
    if (environment = this->GetDrawingEnvironment())
    {
        this->SetBackColor(environment->fBackgroundColor);
        this->InstallColor(environment->fForegroundColor, FALSE);
    }
    this->ControlArea(theRect);

//    Center the check box vertically
    long height = theRect.bottom - theRect.top;
    height -= 14;
    long top = height / 2;
    fDrawBox.top += top;
    fDrawBox.bottom += top;

} // T3DCheckBox::DoPostCreate


//-------------------------------------------------------------------------------------
// T3DCheckBox::I3DCheckBox
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DCheckBox::I3DCheckBox (TView* itsSuperView, const VPoint& itsLocation,
                                 const VPoint& itsSize, SizeDeterminer itsHSizeDet,
                                 SizeDeterminer itsVSizeDet, const CStr255& itsLabel,
                                 Boolean isTurnedOn)
{
    VRect                    theRect;
    TDrawingEnvironment     *environment;

    this->ICheckBox (itsSuperView, itsLocation, itsSize, itsHSizeDet, itsVSizeDet, itsLabel, isTurnedOn);

//    If we have a drawing environment, use it for drawing!
    if (environment = this->GetDrawingEnvironment())
    {
        this->SetBackColor(environment->fBackgroundColor);
        this->InstallColor(environment->fForegroundColor, FALSE);
    }
    this->ControlArea(theRect);

//    Center the check box vertically
    long height = theRect.bottom - theRect.top;
    height -= 14;
    long top = height / 2;
    fDrawBox.top += top;
    fDrawBox.bottom += top;


} // T3DCheckBox::I3DCheckBox


//-------------------------------------------------------------------------------------
// T3DCheckBox::Clone
//-------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal TObject* T3DCheckBox::Clone ()                // OVERRIDE
{

    T3DCheckBox*    aClonedCheckBox;

    aClonedCheckBox = (T3DCheckBox *)(inherited::Clone ());

    aClonedCheckBox->fBackColor = fBackColor;
    aClonedCheckBox->fForeColor = fForeColor;

    return aClonedCheckBox;

} // T3DCheckBox::Clone


//-------------------------------------------------------------------------------------
// T3DCheckBox::Free
//-------------------------------------------------------------------------------------
#pragma segment A3DControlClose

pascal void T3DCheckBox::Free ()                    // OVERRIDE
{
    inherited::Free ();

} // T3DCheckBox::Free


//----------------------------------------------------------------------------------------
// T3DCheckBox::Draw:
//----------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DCheckBox::Draw (const VRect& /*area*/)
{
    VRect             theRect;
    CRect            qdArea;
    CStr255            label;
    CGraphicsState    remember;

    this->ControlArea(theRect);
    this->ViewToQDRect(theRect, qdArea);

    this->DrawBox();
    this->DrawCheck();

    this->GetText (label);
    CRect textBox = qdArea;

//    Move the text 3 pixels to the right of the check box
    textBox.left += (short) fDrawBox.right + 3;
    DrawBoxText (label, textBox, FALSE);

} // T3DCheckBox::Draw


//-------------------------------------------------------------------------------------
// T3DButton::DoMouseCommand
//-------------------------------------------------------------------------------------
#pragma segment A3DControlSelCommand

pascal void T3DCheckBox::DoMouseCommand(VPoint& theMouse,
                                                 TToolboxEvent* ,
                                                 CPoint)        // override
{
    TControlTracker * aControlTracker = new TControlTracker;
    aControlTracker->IControlTracker(this, theMouse);
    this->PostCommand(aControlTracker);
} // T3DCheckBox::DoMouseCommand

//-------------------------------------------------------------------------------------
// T3DCheckBox::TrackMouse
//-------------------------------------------------------------------------------------
#pragma segment A3DControlSelCommand

pascal void T3DCheckBox::TrackMouse(TrackPhase aTrackPhase,
                                                             VPoint& ,
                                                             // anchorPoint
                                                             VPoint& ,
                                                             // previousPoint
                                                             VPoint& nextPoint,
                                                             Boolean)                            // OVERRIDE
{
    Boolean state = false;

    if (!this->IsDimmed())
        switch(aTrackPhase)
        {
            case trackBegin:
                state = fHilite;
                this->HiliteState(TRUE, kRedraw);
                break;
            case trackContinue:
                if (this->ContainsMouse(nextPoint))
                    this->HiliteState(TRUE, kRedraw);
                else
                    this->HiliteState(state, kRedraw);
                break;
            case trackEnd:
                if (this->ContainsMouse(nextPoint))
                {
                    this->HiliteState(FALSE, this->IsOn());
                    this->HandleEvent(fEventNumber, this, NULL);
                }
                break;
        }
}    // T3DCheckBox::TrackMouse


//----------------------------------------------------------------------------------------
// T3DCheckBox::SetLongVal:
//    Override the way the control works so that we don't call the CDEF
//----------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DCheckBox::SetLongVal(VCoordinate itsVal,
                                Boolean /*redraw*/)
{

    itsVal = Max(fLongMin, Min(itsVal, fLongMax));
    if (itsVal != fLongVal)
    {
        fLongVal = itsVal;
        CRect tempRect;
        this->ViewToQDRect(fDrawBox, tempRect);
        InsetRect(tempRect, 2,2);
        this->InvalidateRect(tempRect);
    }
} // T3DCheckBox::SetLongVal


//----------------------------------------------------------------------------------------
// T3DCheckBox::HiliteState:
//----------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal void T3DCheckBox::HiliteState(Boolean state,Boolean redraw)
{
    if (state != fHilite)
    {
        fHilite = state;
        if (state)                                // hilite adorner draws the hilite state
            this->AddAdorner(gHiliteAdorner, kAdornLast - 5, kDontRedraw);
        else
            this->DeleteAdorner(gHiliteAdorner, kDontRedraw);
        if (redraw)
            this->Hilite();
    }
} // T3DCheckBox::HiliteState


//----------------------------------------------------------------------------------------
// T3DCheckBox::DimState:
//----------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal void T3DCheckBox::DimState(Boolean state,
                               Boolean redraw)
{
    if (state != fDimmed)
    {
        fDimmed = state;
        if (state)                                // dim adorner draws the dim state
            this->AddAdorner(gDimAdorner, kAdornLast - 10, kDontRedraw);
        else
            this->DeleteAdorner(gDimAdorner, kDontRedraw);
        if (redraw)
            this->DrawContents();                // Draw change immediately
    }
} // T3DCheckBox::DimState


//-------------------------------------------------------------------------------------
// T3DCheckBox::Hilite
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DCheckBox::Hilite ()        // OVERRIDE
{

    VRect                area;
    CRect                qdArea, qdBox;
    CGraphicsState        rememberGState;

    #if qDebug
        this->AssumeFocused ();
    #endif

    this->ControlArea (area);
    this->ViewToQDRect (area, qdArea);
    this->ViewToQDRect(fDrawBox, qdBox);

    CPenNormal();
    if (fHilite)
    {
        InsetRect(qdBox, 2, 2);
        FrameRect(qdBox);
    }
    else
        this->DrawCheck();
} // T3DCheckBox::Hilite


//-------------------------------------------------------------------------------------
// T3DCheckBox::Dim
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DCheckBox::Dim ()        // OVERRIDE
{
    VRect             area;
    CRect             qdArea;
    CGraphicsState    rememberGState;

    this->ControlArea (area);
    area.left += fDrawBox.right;
    this->ViewToQDRect (area, qdArea);

    short pixelSize;
    CDrawPerDevice device(qdArea);
    while (device.NextDevice (pixelSize))
    {
//        If in B & W, do the standard gray pattern.  Non B & W is taken care of in
//            the DrawCheck and DrawBox routines
        if (pixelSize < 2)
        {
            #if qDebug
                this->AssumeFocused ();
            #endif

            InsetRect (qdArea, 1, 1);

            PenPat (&qd.gray);
            PenMode (patBic);
            PaintRect (qdArea);

            InsetRect (qdArea, -1, -1);
        }
    }
} // T3DCheckBox::Dim

//-------------------------------------------------------------------------------------
// T3DCheckBox::DrawBoxText
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DCheckBox::DrawBoxText (const CStr255& s, const CRect& box, Boolean preferOutline)
{
    FontInfo         theFontInfo;
    CRect             localBox = box;
    CRect             qdArea;
    CGraphicsState    rememberGState;

    CWhileOutlinePreferred setOP (preferOutline);

    short textHeight = MAGetFontInfo (theFontInfo);
    CPoint boxSize = localBox.GetSize ();

//    Center the text vertically
    localBox.top += (boxSize.v - textHeight) / 2;
    MoveTo (localBox.left, localBox.top + theFontInfo.ascent);

    short pixelSize;
    CDrawPerDevice device(localBox);
    while (device.NextDevice (pixelSize))
    {
    //    If we're dimmed, draw in gray, else draw in the fore color
        if (pixelSize > 2)
        {
            SetIfBkColor(fBackColor);
            if (this->IsDimmed())
                SetIfColor(kMediumGray);
            else
                SetIfColor(fForeColor);
        }
        MoveTo (localBox.left, localBox.top + theFontInfo.ascent);
        DrawString(s);
    }

} // T3DCheckBox::DrawBoxText


//-------------------------------------------------------------------------------------
// T3DCheckBox::DrawBox
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DCheckBox::DrawBox()
{
    CRect            qdBox;
    short            pixelSize;
    CGraphicsState    rememberGState;

    this->ViewToQDRect(fDrawBox, qdBox);

    CDrawPerDevice device(qdBox);
    while (device.NextDevice (pixelSize))
    {
//            Draw the 3D effect if we're in non B & W
        if (pixelSize > 2)
        {
            if (!this->IsDimmed())
            {
                SetIfColor(gRGBWhite);
                MoveTo(qdBox.left+1, qdBox.bottom-1);
                LineTo(qdBox.right-1, qdBox.bottom-1);
                LineTo(qdBox.right-1, qdBox.top+1);

                SetIfColor(kMediumLightGray);
                MoveTo(qdBox.right, qdBox.top);
                LineTo(qdBox.left, qdBox.top);
                LineTo(qdBox.left, qdBox.bottom);
                SetIfColor(fForeColor);
            }
            else
                SetIfColor(kMediumGray);
        }
        else
            SetIfColor(gRGBBlack);

    //    Now draw the regular check box
        InsetRect(qdBox, 1, 1);
        FrameRect(qdBox);
        InsetRect(qdBox, -1, -1);
    }

}


//-------------------------------------------------------------------------------------
// T3DCheckBox::DrawCheck
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DCheckBox::DrawCheck()
{
    CRect            qdBox;
    CGraphicsState    rememberGState;

    this->ViewToQDRect(fDrawBox, qdBox);

    InsetRect(qdBox, 2, 2);
    SetIfBkColor(gRGBWhite);
    EraseRect(qdBox);

//    Draw the check if we're on
    if (this->IsOn())
    {
        short pixelSize;
        CDrawPerDevice device(qdBox);
        while (device.NextDevice (pixelSize))
        {
            if (pixelSize > 2)
                if (this->IsDimmed())
                    SetIfColor(kMediumGray);

            MoveTo(qdBox.left-1, qdBox.bottom);
            LineTo(qdBox.right-1, qdBox.top);
            MoveTo(qdBox.left, qdBox.top);
            LineTo(qdBox.right, qdBox.bottom);
        }
    }
}


//-------------------------------------------------------------------------------------
// T3DCheckBox::DrawCheck
//        Override because we don't want the inherited method, which uses the CDEF
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DCheckBox::InstallColor(const CRGBColor& theColor,
                                   Boolean redraw)
{
    fForeColor = theColor;
    if (redraw)
        this->ForceRedraw();
}


//-------------------------------------------------------------------------------------
// T3DRadio::Initialize
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DRadio::Initialize ()                // OVERRIDE
{

    inherited::Initialize();

    fBackColor = kLightGray;
    fForeColor = gRGBBlack;
    fDrawBox = VRect(2, 0, 14, 12);        //    A radio button is 12x12

} // T3DRadio::Initialize



//-------------------------------------------------------------------------------------
// T3DRadio::DoPostCreate
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DRadio::DoPostCreate (TDocument *itsDocument) // OVERRIDE
{
    VRect                    theRect;
    TDrawingEnvironment     *environment;

    inherited::DoPostCreate (itsDocument);

//    If we have a drawing environment, use it!
    if (environment = this->GetDrawingEnvironment())
    {
        this->SetBackColor(environment->fBackgroundColor);
        this->InstallColor(environment->fForegroundColor, FALSE);
    }

//    Center the button vertically
    this->ControlArea(theRect);
    long height = theRect.bottom - theRect.top;
    height -= 12;
    long top = height / 2;
    fDrawBox.top += top;
    fDrawBox.bottom += top;

} // T3DRadio::DoPostCreate


//-------------------------------------------------------------------------------------
// T3DRadio::I3DRadio
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DRadio::I3DRadio (TView* itsSuperView, const VPoint& itsLocation,
                                 const VPoint& itsSize, SizeDeterminer itsHSizeDet,
                                 SizeDeterminer itsVSizeDet, const CStr255& itsLabel,
                                 Boolean isTurnedOn)
{
    VRect                    theRect;
    TDrawingEnvironment     *environment;

    this->IRadio (itsSuperView, itsLocation, itsSize, itsHSizeDet, itsVSizeDet, itsLabel, isTurnedOn);

//    If we have a drawing environment, use it!
    if (environment = this->GetDrawingEnvironment())
    {
        this->SetBackColor(environment->fBackgroundColor);
        this->InstallColor(environment->fForegroundColor, FALSE);
    }

//    Center the button vertically
    this->ControlArea(theRect);
    long height = theRect.bottom - theRect.top;
    height -= 12;
    long top = height / 2;
    fDrawBox.top += top;
    fDrawBox.bottom += top;


} // T3DRadio::I3DRadio


//-------------------------------------------------------------------------------------
// T3DRadio::Clone
//-------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal TObject* T3DRadio::Clone ()                // OVERRIDE
{

    T3DRadio*    aClonedRadio;

    aClonedRadio = (T3DRadio *)(inherited::Clone ());

    aClonedRadio->fBackColor = fBackColor;
    aClonedRadio->fForeColor = fForeColor;

    return aClonedRadio;

} // T3DRadio::Clone


//-------------------------------------------------------------------------------------
// T3DRadio::Free
//-------------------------------------------------------------------------------------
#pragma segment A3DControlClose

pascal void T3DRadio::Free ()                    // OVERRIDE
{
    inherited::Free ();

} // T3DRadio::Free


//-------------------------------------------------------------------------------------
// T3DRadio::Draw
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DRadio::Draw (const VRect& /*area*/)
{
    VRect             theRect;
    CRect            qdArea;
    CStr255            label;
    CGraphicsState    rememberGState;

    this->ControlArea(theRect);
    this->ViewToQDRect(theRect, qdArea);

    this->DrawBox();
    this->DrawCheck();

//    Draw the button text 4 pixels to the right of the button
    this->GetText (label);
    CRect textBox = qdArea;
    textBox.left += (short) fDrawBox.right + 4;
    DrawBoxText (label, textBox, FALSE);

} // T3DRadio::Draw


//-------------------------------------------------------------------------------------
// T3DButton::DoMouseCommand
//-------------------------------------------------------------------------------------
#pragma segment A3DControlSelCommand

pascal void T3DRadio::DoMouseCommand(VPoint& theMouse,
                                                 TToolboxEvent* ,
                                                 CPoint)        // override
{
    TControlTracker * aControlTracker = new TControlTracker;
    aControlTracker->IControlTracker(this, theMouse);
    this->PostCommand(aControlTracker);
} // T3DRadio::DoMouseCommand

//-------------------------------------------------------------------------------------
// T3DRadio::TrackMouse
//-------------------------------------------------------------------------------------
#pragma segment A3DControlSelCommand

pascal void T3DRadio::TrackMouse(TrackPhase aTrackPhase,
                                                             VPoint& ,
                                                             // anchorPoint
                                                             VPoint& ,
                                                             // previousPoint
                                                             VPoint& nextPoint,
                                                             Boolean)                            // OVERRIDE
{
    Boolean state = false;

    if (!this->IsDimmed())
        switch(aTrackPhase)
        {
            case trackBegin:
                state = fHilite;
                this->HiliteState(TRUE, kRedraw);
                break;
            case trackContinue:
                if (this->ContainsMouse(nextPoint))
                    this->HiliteState(TRUE, kRedraw);
                else
                    this->HiliteState(state, kRedraw);
                break;
            case trackEnd:
                if (this->ContainsMouse(nextPoint))
                {
                    this->HiliteState(FALSE, this->IsOn());
                    this->HandleEvent(fEventNumber, this, NULL);
                }
                break;
        }
}    // T3DRadio::TrackMouse


//----------------------------------------------------------------------------------------
// T3DRadio::SetLongVal:
//    Override the way the control works so that we don't call the CDEF
//----------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DRadio::SetLongVal(VCoordinate itsVal,
                                Boolean /*redraw*/)
{
    itsVal = Max(fLongMin, Min(itsVal, fLongMax));
    if (itsVal != fLongVal)
    {
        fLongVal = itsVal;
        CRect tempRect;
        this->ViewToQDRect(fDrawBox, tempRect);

//        Make a region for the inside of the button to invalidate
        CTemporaryRegion    region;
        InsetRect(tempRect, 1,1);
        OpenRgn();
        FrameOval(tempRect);
        CloseRgn(region);
        this->InvalidateRegion(region);
    }
} // T3DRadio::SetLongVal


//----------------------------------------------------------------------------------------
// T3DRadio::HiliteState:
//----------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal void T3DRadio::HiliteState(Boolean state,Boolean redraw)
{
    if (state != fHilite)
    {
        fHilite = state;
        if (state)                                // hilite adorner draws the hilite state
            this->AddAdorner(gHiliteAdorner, kAdornLast - 5, kDontRedraw);
        else
            this->DeleteAdorner(gHiliteAdorner, kDontRedraw);
        if (redraw)
            this->Hilite();
    }
} // T3DRadio::HiliteState


//----------------------------------------------------------------------------------------
// T3DRadio::DimState:
//----------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal void T3DRadio::DimState(Boolean state,
                               Boolean redraw)
{
    if (state != fDimmed)
    {
        fDimmed = state;
        if (state)                                // dim adorner draws the dim state
            this->AddAdorner(gDimAdorner, kAdornLast - 10, kDontRedraw);
        else
            this->DeleteAdorner(gDimAdorner, kDontRedraw);
        if (redraw)
            this->DrawContents();                // Draw change immediately
    }
} // T3DRadio::DimState


//-------------------------------------------------------------------------------------
// T3DRadio::Hilite
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DRadio::Hilite ()        // OVERRIDE
{

    VRect            area;
    CRect            qdArea, qdBox;
    CGraphicsState    rememberGState;

    #if qDebug
        this->AssumeFocused ();
    #endif

    this->ControlArea (area);
    this->ViewToQDRect (area, qdArea);
    this->ViewToQDRect(fDrawBox, qdBox);

    CPenNormal();
    if (fHilite)
    {
        InsetRect(qdBox, 1, 1);
        FrameOval(qdBox);
        InsetRect(qdBox, 1,1);

//        Erase the content of the oval
        SetIfBkColor(fBackColor);
        if (this->IsOn())
        {
            PenPat(&qd.white);
            FrameOval(qdBox);
        }
        else
            EraseOval(qdBox);
    }
    else
        this->DrawCheck();
} // T3DRadio::Hilite


//-------------------------------------------------------------------------------------
// T3DRadio::Dim
//-------------------------------------------------------------------------------------
#pragma segment ControlRes

pascal void T3DRadio::Dim ()        // OVERRIDE
{
    VRect             area;
    CRect             qdArea;
    CGraphicsState    rememberGState;

    this->ControlArea (area);
    area.left += fDrawBox.right;
    this->ViewToQDRect (area, qdArea);

    short pixelSize;
    CDrawPerDevice device(qdArea);
    while (device.NextDevice (pixelSize))
    {
//        Do the normal gray pattern thing if we're in B & W
        if (pixelSize < 2)
        {
            #if qDebug
                this->AssumeFocused ();
            #endif

            InsetRect (qdArea, 1, 1);

            PenPat (&qd.gray);
            PenMode (patBic);
            PaintRect (qdArea);
            InsetRect (qdArea, -1, -1);
        }
    }
} // T3DRadio::Dim

//-------------------------------------------------------------------------------------
// T3DRadio::DrawBoxText
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DRadio::DrawBoxText (const CStr255& s, const CRect& box, Boolean preferOutline)
{
    FontInfo         theFontInfo;
    CRect             localBox = box;
    CRect            qdArea;
    CGraphicsState    rememberGState;

    CWhileOutlinePreferred setOP (preferOutline);

    short textHeight = MAGetFontInfo (theFontInfo);
    CPoint boxSize = localBox.GetSize ();

//    Center the text horizontally
    localBox.top += (boxSize.v - textHeight) / 2;
    MoveTo (localBox.left, localBox.top + theFontInfo.ascent);

    short pixelSize;
    CDrawPerDevice device(localBox);
    while (device.NextDevice (pixelSize))
    {
    //    If we're dimmed, draw in gray, else draw in the fore color
        if (pixelSize > 2)
        {
            SetIfBkColor(fBackColor);
            if (this->IsDimmed())
                //    Draw the text in gray if we can
                SetIfColor(kMediumGray);
            else
                SetIfColor(fForeColor);
        }
        MoveTo (localBox.left, localBox.top + theFontInfo.ascent);
        DrawString (s);        // This would be faster if we did StringWidth and DrawChar...
    }

} // T3DRadio::DrawBoxText


//-------------------------------------------------------------------------------------
// T3DRadio::DrawBox
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DRadio::DrawBox()
{
    CRect            qdBox;
    CGraphicsState    rememberGState;

    this->ViewToQDRect(fDrawBox, qdBox);

    short pixelSize;
    CDrawPerDevice device(qdBox);
    while (device.NextDevice (pixelSize))
    {
        if (pixelSize > 2)
        {
            if (this->IsDimmed())
                SetIfColor(kMediumGray);
            else
                SetIfColor(fForeColor);
        }
        FrameOval(qdBox);
    }
}


//-------------------------------------------------------------------------------------
// T3DRadio::DrawCheck
//        This actually draws a dot, but I wanted to keep it similar to the check box
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DRadio::DrawCheck()
{
    CRect            qdBox;
    short            pixelSize;
    CGraphicsState    rememberGState;

    this->ViewToQDRect(fDrawBox, qdBox);

//    First erase the oval
    InsetRect(qdBox, 1, 1);
    if (this->IsDimmed())
        SetIfBkColor(fBackColor);
    else
        SetIfBkColor(gRGBWhite);
    EraseOval(qdBox);
    InsetRect(qdBox, -1, -1);

//    Check to see if we're on
    if (this->IsOn())
    {
        CDrawPerDevice device(qdBox);
        while (device.NextDevice (pixelSize))
        {
//                This takes some pretty subtle work
            if (pixelSize > 2)
            {
                if (!this->IsDimmed())
                {
                    SetIfColor(kLightGray);
                    MoveTo(qdBox.left + 9, qdBox.top + 5);
                    LineTo(qdBox.left + 9, qdBox.top + 7);
                    MoveTo(qdBox.left + 5, qdBox.top + 9);
                    LineTo(qdBox.left + 7, qdBox.top + 9);

                    SetIfColor(kLightGray2);
                    MoveTo(qdBox.left + 3, qdBox.top + 9);
                    LineTo(qdBox.left + 4, qdBox.top + 9);
                    MoveTo(qdBox.left + 9, qdBox.top + 3);
                    LineTo(qdBox.left + 9, qdBox.top + 4);

                    SetIfColor(kLightGray4);
                    MoveTo(qdBox.left + 2, qdBox.top + 9);
                    LineTo(qdBox.left + 2, qdBox.top + 8);
                    LineTo(qdBox.left + 3, qdBox.top + 8);
                    MoveTo(qdBox.left + 8, qdBox.top + 3);
                    LineTo(qdBox.left + 8, qdBox.top + 2);
                    LineTo(qdBox.left + 9, qdBox.top + 2);

                    SetIfColor(kMediumLightGray);
                    MoveTo(qdBox.left + 2, qdBox.top + 7);
                    LineTo(qdBox.left + 2, qdBox.top + 4);
                    LineTo(qdBox.left + 4, qdBox.top + 2);
                    LineTo(qdBox.left + 7, qdBox.top + 2);

                    SetIfColor(kMediumGray);
                    MoveTo(qdBox.left + 1, qdBox.top + 7);
                    LineTo(qdBox.left + 1, qdBox.top + 4);
                    LineTo(qdBox.left + 4, qdBox.top + 1);
                    LineTo(qdBox.left + 7, qdBox.top + 1);
                    MoveTo(qdBox.left + 2, qdBox.top + 2); // this is faster
                    LineTo(qdBox.left + 2, qdBox.top + 2); // than SetCPixel
                    SetIfColor(gRGBBlack);
                }
                else
                    SetIfColor(kMediumGray);
            }
            else
                SetIfColor(gRGBBlack);
            InsetRect(qdBox, 3,3);
            FillOval(qdBox, &qd.black);
            InsetRect(qdBox, -3, -3);
        }
    }
//    This is how we look when we're off
    else
    {
//        Off and dimmed takes some work, off and not dimmed takes no work
        if (!this->IsDimmed())
        {
            CDrawPerDevice device(qdBox);
            while (device.NextDevice (pixelSize))
            {
                if (pixelSize > 2)
                {
                    SetIfColor(kLightGray);
                    MoveTo(qdBox.left + 6, qdBox.top + 2);
                    LineTo(qdBox.left + 3, qdBox.top + 5);
                    MoveTo(qdBox.left + 4, qdBox.top + 5);
                    LineTo(qdBox.left + 7, qdBox.top + 2);
                    MoveTo(qdBox.left + 3, qdBox.top + 5);
                    LineTo(qdBox.left + 3, qdBox.top + 7);

                    SetIfColor(kLightGray2);
                    MoveTo(qdBox.left + 3, qdBox.top + 8);
                    LineTo(qdBox.left + 4, qdBox.top + 8);
                    LineTo(qdBox.left + 4, qdBox.top + 6);
                    LineTo(qdBox.left + 6, qdBox.top + 6);
                    LineTo(qdBox.left + 6, qdBox.top + 4);
                    LineTo(qdBox.left + 7, qdBox.top + 4);
                    LineTo(qdBox.left + 7, qdBox.top + 3);
                    LineTo(qdBox.left + 8, qdBox.top + 3);
                    LineTo(qdBox.left + 8, qdBox.top + 2);
                    MoveTo(qdBox.left + 5, qdBox.top + 5);
                    LineTo(qdBox.left + 5, qdBox.top + 5);
                    MoveTo(qdBox.left + 7, qdBox.top + 5);
                    LineTo(qdBox.left + 7, qdBox.top + 5);
                    MoveTo(qdBox.left + 5, qdBox.top + 7);
                    LineTo(qdBox.left + 5, qdBox.top + 7);

                    SetIfColor(kLightGray4);
                    MoveTo(qdBox.left + 3, qdBox.top + 9);
                    LineTo(qdBox.left + 5, qdBox.top + 9);
                    LineTo(qdBox.left + 5, qdBox.top + 8);
                    LineTo(qdBox.left + 6, qdBox.top + 8);
                    LineTo(qdBox.left + 6, qdBox.top + 7);
                    LineTo(qdBox.left + 7, qdBox.top + 7);
                    LineTo(qdBox.left + 7, qdBox.top + 6);
                    LineTo(qdBox.left + 8, qdBox.top + 6);
                    LineTo(qdBox.left + 8, qdBox.top + 4);

                    SetIfColor(kMediumLightGray);
                    MoveTo(qdBox.left + 6, qdBox.top + 9);
                    LineTo(qdBox.left + 7, qdBox.top + 9);
                    LineTo(qdBox.left + 7, qdBox.top + 8);
                    LineTo(qdBox.left + 8, qdBox.top + 8);
                    LineTo(qdBox.left + 8, qdBox.top + 7);
                    LineTo(qdBox.left + 9, qdBox.top + 7);
                    LineTo(qdBox.left + 9, qdBox.top + 2);

                    SetIfColor(kMediumGray);
                    MoveTo(qdBox.left + 4, qdBox.top + 10);
                    LineTo(qdBox.left + 7, qdBox.top + 10);
                    MoveTo(qdBox.left + 8, qdBox.top + 9);
                    LineTo(qdBox.left + 9, qdBox.top + 9);
                    LineTo(qdBox.left + 9, qdBox.top + 8);
                    MoveTo(qdBox.left + 10, qdBox.top + 7);
                    LineTo(qdBox.left + 10, qdBox.top + 4);

                }
            }
        }
    }
}


//-------------------------------------------------------------------------------------
// T3DRadio::InstallColor
//        Override because we don't want the inherited method, which uses the CDEF
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DRadio::InstallColor(const CRGBColor& theColor,
                                   Boolean redraw)
{
    fForeColor = theColor;
    if (redraw)
        this->ForceRedraw();
}



//=====================================================================================
// CLASS:    T3DButton
//    A 3D version of our old friend the Button
//=====================================================================================

//-------------------------------------------------------------------------------------
// T3DButton::Initialize
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DButton::Initialize ()                // OVERRIDE
{

    inherited::Initialize();

    f3DAdorner = NULL;
    fHilitedTextColor = gRGBBlack;

} // T3DButton::Initialize


//-------------------------------------------------------------------------------------
// T3DButton::DoPostCreate
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DButton::DoPostCreate (TDocument *itsDocument) // OVERRIDE
{

    inherited::DoPostCreate (itsDocument);

    if (f3DAdorner == NULL)
        this->CreateButtonAdorner ();

} // T3DButton::DoPostCreate


//-------------------------------------------------------------------------------------
// T3DButton::I3DButton
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DButton::I3DButton (TView* itsSuperView,  const VPoint& itsLocation,
                                                           const VPoint& itsSize,
                                                           SizeDeterminer itsHSizeDet,
                                                           SizeDeterminer itsVSizeDet,
                                                         const CStr255& itsLabel)
{

    this->IButton(itsSuperView, itsLocation, itsSize, itsHSizeDet, itsVSizeDet, itsLabel);

    //    • If we are being built procedurally then build the adorner
    if (f3DAdorner == NULL)
        this->CreateButtonAdorner ();

} // T3DButton::I3DButton

//-------------------------------------------------------------------------------------
// T3DButton::Clone
//-------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal TObject* T3DButton::Clone ()                // OVERRIDE
{
    T3DButton*    aClonedButton;

    aClonedButton = (T3DButton *)(inherited::Clone ());
    aClonedButton->fHilitedTextColor = fHilitedTextColor;
    aClonedButton->CreateButtonAdorner();

    return aClonedButton;

} // T3DButton::Clone

//-------------------------------------------------------------------------------------
// T3DButton::Free
//-------------------------------------------------------------------------------------
#pragma segment A3DControlClose

pascal void T3DButton::Free ()                    // OVERRIDE
{
    inherited::Free ();

} // T3DButton::Free

//-------------------------------------------------------------------------------------
// T3DButton::DoMouseCommand
//-------------------------------------------------------------------------------------
pascal void T3DButton::DoMouseCommand(VPoint& theMouse,
                                                 TToolboxEvent* ,
                                                 CPoint)        // override
{
    TControlTracker * aControlTracker = new TControlTracker;
    aControlTracker->IControlTracker(this, theMouse);
    this->PostCommand(aControlTracker);
} // TControl::DoMouseCommand

//-------------------------------------------------------------------------------------
// T3DButton::TrackMouse
//-------------------------------------------------------------------------------------
#pragma segment A3DControlSelCommand

pascal void T3DButton::TrackMouse(TrackPhase aTrackPhase,
                                                             VPoint& ,
                                                             // anchorPoint
                                                             VPoint& ,
                                                             // previousPoint
                                                             VPoint& nextPoint,
                                                             Boolean)                            // OVERRIDE
{
    Boolean state = false;

    if (!this->IsDimmed())
        switch(aTrackPhase)
        {
            case trackBegin:
                state = fHilite;
                this->HiliteState(TRUE, kRedraw);
                break;
            case trackContinue:
                if (this->ContainsMouse(nextPoint))
                    this->HiliteState(TRUE, kRedraw);
                else
                    this->HiliteState(state, kRedraw);
                break;
            case trackEnd:
                if (this->ContainsMouse(nextPoint))
                {
                    this->HiliteState(FALSE, kRedraw);
                    this->HandleEvent(fEventNumber, this, NULL);
                }
                break;
        }
}    // T3DButton::TrackMouse

//----------------------------------------------------------------------------------------
// T3DButton::HiliteState:
//----------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal void T3DButton::HiliteState(Boolean state,Boolean redraw)
{
    if (state != fHilite)
    {
        fHilite = state;
        if (state)                                // hilite adorner draws the hilite state
            this->AddAdorner(gHiliteAdorner, kAdornLast - 5, kDontRedraw);
        else
            this->DeleteAdorner(gHiliteAdorner, kDontRedraw);
        if (redraw && this->IsDrawable())
            this->Hilite();
    }
} // T3DButton::HiliteState


//----------------------------------------------------------------------------------------
// T3DButton::DimState:
//----------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal void T3DButton::DimState(Boolean state,
                               Boolean redraw)
{
    if (state != fDimmed)
    {
        fDimmed = state;
        if (state)                                // dim adorner draws the dim state
            this->AddAdorner(gDimAdorner, kAdornLast - 10, kDontRedraw);
        else
            this->DeleteAdorner(gDimAdorner, kDontRedraw);
        if (redraw)
            this->DrawContents();                // Draw change immediately
    }
} // T3DButton::DimState

//-------------------------------------------------------------------------------------
// T3DButton::CreateButtonAdorner
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DButton::CreateButtonAdorner ()
{

    // •    Add the Button Adorner
    T3DTextButtonAdorner* adorner = new T3DTextButtonAdorner;
    adorner->I3DTextButtonAdorner (kFreeOnDeletion);
    f3DAdorner = adorner;

    this->AddAdorner (adorner, kAdornFirst, kDontInvalidate);

} // T3DButton::CreateButtonAdorner

//-------------------------------------------------------------------------------------
// T3DButton::DrawBoxText
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DButton::DrawBoxText (    const CStr255& s,
                                                             const CRect& box,
                                                             Boolean preferOutline)
{

    FontInfo     theFontInfo;
    CRect         qdArea, localBox = box;
    CGraphicsState    remember;

    CWhileOutlinePreferred setOP (preferOutline);

    short textHeight = MAGetFontInfo (theFontInfo);
    CPoint boxSize = localBox.GetSize ();

//    Center the text in the button
    localBox.left += (boxSize.h - StringWidth (s)) / 2;
    localBox.top += (boxSize.v - textHeight) / 2;

    this->ViewToQDRect (localBox, qdArea);
    short    pixelSize;
    CDrawPerDevice device(qdArea);
    while (device.NextDevice (pixelSize))
    {
        if (pixelSize >= 4)
        {
        //    If we're non B & W and we're dimmed, draw in gray text
            if (this->IsDimmed())
                SetIfColor(kMediumGray);
        //    If we're hilited, use the hilite text color
            else if (fHilite)
                SetIfColor(fHilitedTextColor);
        }
        MoveTo (localBox.left, localBox.top + theFontInfo.ascent);
        DrawString (s);
    }

} // T3DButton::DrawBoxText

//-------------------------------------------------------------------------------------
// T3DButton::Draw
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DButton::Draw (const VRect& /*area*/)        // OVERRIDE
{

    VRect         theRect;
    CRect        qdArea;
    CStr255        label;

    this->ControlArea (theRect);
    this->ViewToQDRect (theRect, qdArea);

    this->GetText (label);

//    Just draw the text.  The adorner takes care of the 3D stuff
    DrawBoxText (label, qdArea, FALSE);

} // T3DButton::Draw

//-------------------------------------------------------------------------------------
// T3DButton::Hilite
//-------------------------------------------------------------------------------------
#pragma segment ControlRes

pascal void T3DButton::Hilite ()        // OVERRIDE
{

    VRect            area;
    CRect            qdArea;
    CGraphicsState    rememberGState;

    #if qDebug
        this->AssumeFocused ();
    #endif

    this->ControlArea (area);
    this->ViewToQDRect (area, qdArea);

    short    pixelSize;
    CDrawPerDevice device(qdArea);
//    We use some funky logic here because of the way the 3d adorner works.
//  For 4, 8 and above, we draw one way.  Otherwise we draw another way
//    See the adorner code for more info
    while (device.NextDevice (pixelSize))
    {
        if (pixelSize < 4)
        {
//            We need to draw the text BEFORE the adorner if we're B & W
            if (fHilite)
            {
                this->Draw (area);
                f3DAdorner->Draw (this, area);
            }
            else
            {
                f3DAdorner->Draw(this, area);
                this->Draw(area);
            }
        }
        else
        {
//            We need to draw the text AFTER the adorner for better than B & W
            f3DAdorner->Draw(this, area);
            this->Draw(area);
        }
    }
} // T3DButton::Hilite

//-------------------------------------------------------------------------------------
// T3DButton::Dim
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DButton::Dim ()        // OVERRIDE
{

    VRect            area;
    CRect            qdArea;
    CGraphicsState     rememberGState;

    #if qDebug
        this->AssumeFocused ();
    #endif

    this->ControlArea (area);
    this->ViewToQDRect (area, qdArea);
    InsetRect (qdArea, 1, 1);

    short pixelSize;
    CDrawPerDevice device(qdArea);
    while (device.NextDevice (pixelSize))
    {
//        The old fashioned way is to use a gray pattern to dim
        if (pixelSize < 2)
        {
            #if qDebug
                this->AssumeFocused ();
            #endif

            InsetRect (qdArea, 1, 1);

            PenPat (&qd.gray);
            PenMode (patBic);
            PaintRect (qdArea);
            InsetRect (qdArea, -1, -1);
        }
    }

} // T3DButton::Dim


//=====================================================================================
// T3DTextButtonAdorner
//        This is an auxiliary adorner for T3DButtons
//=====================================================================================

//-------------------------------------------------------------------------------------
// T3DTextButtonAdorner::I3DTextButtonAdorner
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DTextButtonAdorner::I3DTextButtonAdorner (    Boolean freeOnDeletion)
{
    //    • Call our superclass to complete initialization
    this->IAdorner (k3DTextButtonAdorner,freeOnDeletion);

} // T3DTextButtonAdorner::I3DTextButtonAdorner

//=====================================================================================
// •• DRAWING
//-------------------------------------------------------------------------------------
// T3DTextButtonAdorner::Draw
//-------------------------------------------------------------------------------------
//
//    This overridden draw method handles the drawing of the buttons border and then
//    branches to the appropriate appropriate method to draw the buttons contents, based
//    on the bit depth of the device being drawn to.  Currently this method supports 1, 4,
//    and 8 bit or more devices.

#pragma segment A3DControlRes

pascal void T3DTextButtonAdorner::Draw (    TView* itsView,
                                                const VRect& /*area*/)
{

    VRect                theRect;
    CRect                qdArea;
    short                pixelSize;
    CRGBColor            color;

    //    • Instantiate a stack based object that saves our graphic state
    CGraphicsState aGraphicsState;

    //    •    Coerce the view to a control and then get its QD area
    TControl* theControl = (TControl*)itsView;
    theControl->ControlArea (theRect);
    theControl->ViewToQDRect (theRect, qdArea);

    //    • Instantiate the stack based object that handles the per device clipping
    //    the area is passed in so that the object can do clipping from it
    CDrawPerDevice device (qdArea);

    //    • We will cycle through all of the devices, drawing will be handle based on
    //    the pixel size for each device
    while (device.NextDevice (pixelSize))
    {

        //    • Draw the button with full colors
        if (pixelSize >= 8)
        {
            //    • First step is to setup the appropriate gray fill color
            if (theControl->fHilite)
                color = kMediumGray;
            else if (((TButton *)itsView)->IsDimmed())
                color = kLightGray;
            else
                color = kLightGray2;

            //    • Fill the round rect with the color
            SetIfColor (color);
            PaintRoundRect (qdArea, kOvalWidth, kOvalHeight);

            //    • Frame button with a black border or gray if it's dimmed
            if (((TButton *)itsView)->IsDimmed())
                SetIfColor(kMediumGray);
            else
                SetIfColor (gRGBBlack);
            this->Frame (qdArea);

            //    • Inset the area in preparartion for the drawing of the buttons content
            InsetRect (qdArea, 1, 1);

            //    • Draw the button assuming 8 bit or better color
            //         But don't draw any 3D if we're dimmed
            if (!((TButton *)itsView)->IsDimmed())
                this->Draw8Bit (qdArea, theControl->fHilite);

            InsetRect (qdArea, -1, -1);

        }
        else if (pixelSize == 4)    //    • Draw with only 16 colors
        {

            //    • First step is to setup the appropriate gray fill color
            if (theControl->fHilite)
                SetRGBColor (color, kRGB4BitGray2, kRGB4BitGray2, kRGB4BitGray2);
            else if (((TButton *)itsView)->IsDimmed())
                color = kLightGray;
            else
                SetRGBColor (color, kRGB4BitGray1, kRGB4BitGray1, kRGB4BitGray1);

            //    • Fill the round rect with the color
            SetIfColor (color);
            PaintRoundRect (qdArea, kOvalWidth, kOvalHeight);

            //    • Frame button with a black border or gray if we're dimmed
            if (((TButton *)itsView)->IsDimmed())
                SetIfColor(kMediumGray);
            else
                SetIfColor (gRGBBlack);
            this->Frame (qdArea);

            //    • Inset the area in preparartion for the drawing of the buttons content
            InsetRect (qdArea, 1, 1);

            //    • For now we will draw the 1 bit style for 4 bit, but this should be
            //    replaced with a 4 bit algorithm which will give you 3 shades of gray
            //         But don't draw any 3D if we're dimmed
            if (!((TButton *)itsView)->IsDimmed())
                this->Draw4Bit (qdArea, theControl->fHilite);

            InsetRect (qdArea, -1, -1);

        }
        else if (pixelSize < 4)    //    • Draw with 4 colors or less (no grays)
        {
            //    • We are hiliting so we need to invert the whole thing
            if  (theControl->fHilite)
            {
                //    • First we paint the inside white
                InvertRoundRect (qdArea, kOvalWidth, kOvalHeight);

                //    • Frame button with a black border
                SetIfColor (gRGBBlack);
                this->Frame (qdArea);
            }
            else
            {
                //    • First we erase the entire area
                SetIfBkColor (gRGBWhite);
                EraseRoundRect (qdArea, kOvalWidth, kOvalHeight);

                //    • Frame button with a black border
                SetIfColor (gRGBBlack);
                this->Frame (qdArea);
            }
        }
    }

} // T3DTextButtonAdorner::Draw

//=====================================================================================
// •• PRIVATE DRAWING
//-------------------------------------------------------------------------------------
// T3DTextButtonAdorner::Draw8Bit
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DTextButtonAdorner::Draw8Bit (const CRect& rect,
                                                    Boolean hilite)
{
    CRect             insetArea;
    CRect             controlArea;
    CRGBColor         color;
    CRGBColor         light;
    CRGBColor         dark;

    //    • Make a copy of the rect passed in
    controlArea = rect;

    //    • Save off the area passed in
    insetArea = rect;

    //    • Draw the hilited button
    if (hilite)
    {

        //    • Outside edge of left top shadow
        SetRGBColor (color, kRGB8BitGray9, kRGB8BitGray9, kRGB8BitGray9);
        SetIfColor (color);
        MoveTo (controlArea.left, controlArea.bottom - 3);
        LineTo (controlArea.left, controlArea.top + 2);
        MoveTo (controlArea.left + 2, controlArea.top);
        LineTo (controlArea.right - 3, controlArea.top);

        //    • Outside edge of bottom right shadow
        SetRGBColor (color, kRGB8BitGray3, kRGB8BitGray3, kRGB8BitGray3);
        SetIfColor (color);
        MoveTo (controlArea.left + 2, controlArea.bottom - 1);
        LineTo (controlArea.right - 3, controlArea.bottom - 1);
        MoveTo (controlArea.right - 1, controlArea.bottom - 3);
        LineTo (controlArea.right - 1, controlArea.top + 2);

        //    • Inset our rectangle as we move to the next level
        InsetRect (controlArea, 1, 1);

        //    • Inside edge of left top shadow
        SetRGBColor (color, kRGB8BitGray8, kRGB8BitGray8, kRGB8BitGray8);
        SetIfColor (color);
        MoveTo (controlArea.left, controlArea.bottom - 2);
        LineTo (controlArea.left, controlArea.top + 1);
        MoveTo (controlArea.left + 1, controlArea.top);
        LineTo (controlArea.right - 2, controlArea.top);

        //    • Inside edge of bottom right shadow
        color = kMediumLightGray;
        SetIfColor (color);
        MoveTo (controlArea.left + 1, controlArea.bottom - 1);
        LineTo (controlArea.right - 2, controlArea.bottom - 1);
        MoveTo (controlArea.right - 1, controlArea.bottom - 2);
        LineTo (controlArea.right - 1, controlArea.top + 1);

        //    •• Now draw the corners
        //    •    TopLeft 1
        SetRGBColor (light, kRGB8BitGray8, kRGB8BitGray8, kRGB8BitGray8);
        SetRGBColor (dark, kRGB8BitGray9, kRGB8BitGray9, kRGB8BitGray9);
        this->TopLeftCorner (insetArea, light, dark, hilite);

        //    • TopRight 2
        SetRGBColor (light, kRGB8BitGray8, kRGB8BitGray8, kRGB8BitGray8);
        SetRGBColor (dark, kRGB8BitGray9, kRGB8BitGray9, kRGB8BitGray9);
        this->TopRightCorner (insetArea, light, dark, hilite);

        //    • BotLeft 3
        //    • Colors same as previous corner
        this->BotLeftCorner (insetArea, light, dark, hilite);

        //    • BotRight 4
        SetRGBColor (light, kRGB8BitGray3, kRGB8BitGray3, kRGB8BitGray3);
        dark = kMediumLightGray;
        this->BotRightCorner (insetArea, light, dark, hilite);

    }
    else //    • Draw the unhilited button
    {

        //    • Outside edge of bottom right shadow
        SetRGBColor (color, kRGB8BitGray8, kRGB8BitGray8, kRGB8BitGray8);
        SetIfColor (color);
        MoveTo (controlArea.left + 2, controlArea.bottom - 1);
        LineTo (controlArea.right - 3, controlArea.bottom - 1);
        MoveTo (controlArea.right - 1, controlArea.bottom - 3);
        LineTo (controlArea.right - 1, controlArea.top + 2);

        //    • Inset our rectangle as we move to the next level
        InsetRect (controlArea, 1, 1);

        //    • Light on edge of button - light source edge
        SetIfColor (gRGBWhite);
        MoveTo (controlArea.left, controlArea.bottom - 2);
        LineTo (controlArea.left, controlArea.top + 1);
        MoveTo (controlArea.left + 1, controlArea.top);
        LineTo (controlArea.right - 2, controlArea.top);

        //    • Inside edge of bottom right shadow
        color = kMediumGray;
        SetIfColor (color);
        MoveTo (controlArea.left + 1, controlArea.bottom - 1);
        LineTo (controlArea.right - 2, controlArea.bottom - 1);
        MoveTo (controlArea.right - 1, controlArea.bottom - 2);
        LineTo (controlArea.right - 1, controlArea.top + 1);

        //    •• Now draw the corners
        //    •    TopLeft 1
        this->TopLeftCorner (insetArea, gRGBWhite, gRGBWhite, hilite);

        //    • TopRight 2
        light = kLightGray4;
        this->TopRightCorner (insetArea, light, light, hilite);

        //    • BotLeft 3
        //    • Colors same as previous corner
        this->BotLeftCorner (insetArea, light, light, hilite);

        //    • BotRight 4
        light = kMediumGray;
        SetRGBColor (dark, kRGB8BitGray8, kRGB8BitGray8, kRGB8BitGray8);
        this->BotRightCorner (insetArea, light, dark, hilite);

    }


} // T3DTextButtonAdorner::Draw8Bit

//-------------------------------------------------------------------------------------
// T3DTextButtonAdorner::Draw4Bit
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DTextButtonAdorner::Draw4Bit (const CRect& rect,
                                                    Boolean hilite)
{
    CRect             insetArea;
    CRect             controlArea;
    CRGBColor         color;
    CRGBColor         light;
    CRGBColor         dark;

    //    • Make a copy of the rect passed in
    controlArea = rect;

    //    • Save off the area passed in
    insetArea = rect;

    //    • Draw the hilited button
    if (hilite)
    {

        //    • Outside edge of left top shadow
        SetRGBColor (color, kRGB4BitGray3, kRGB4BitGray3, kRGB4BitGray3);
        SetIfColor (color);
        MoveTo (controlArea.left, controlArea.bottom - 3);
        LineTo (controlArea.left, controlArea.top + 2);
        MoveTo (controlArea.left + 2, controlArea.top);
        LineTo (controlArea.right - 3, controlArea.top);

        //    • Outside edge of bottom right shadow
        SetRGBColor (color, kRGB4BitGray1, kRGB4BitGray1, kRGB4BitGray1);
        SetIfColor (color);
        MoveTo (controlArea.left + 2, controlArea.bottom - 1);
        LineTo (controlArea.right - 3, controlArea.bottom - 1);
        MoveTo (controlArea.right - 1, controlArea.bottom - 3);
        LineTo (controlArea.right - 1, controlArea.top + 2);

        //    • Inset our rectangle as we move to the next level
        InsetRect (controlArea, 1, 1);

        //    • Inside edge of left top shadow
        SetRGBColor (color, kRGB4BitGray3, kRGB4BitGray3, kRGB4BitGray3);
        SetIfColor (color);
        MoveTo (controlArea.left, controlArea.bottom - 2);
        LineTo (controlArea.left, controlArea.top + 1);
        MoveTo (controlArea.left + 1, controlArea.top);
        LineTo (controlArea.right - 2, controlArea.top);

        //    • Inside edge of bottom right shadow
        SetRGBColor (color, kRGB4BitGray1, kRGB4BitGray1, kRGB4BitGray1);
        SetIfColor (color);
        MoveTo (controlArea.left + 1, controlArea.bottom - 1);
        LineTo (controlArea.right - 2, controlArea.bottom - 1);
        MoveTo (controlArea.right - 1, controlArea.bottom - 2);
        LineTo (controlArea.right - 1, controlArea.top + 1);

        //    •• Now draw the corners
        //    •    TopLeft 1
        SetRGBColor (light, kRGB4BitGray3, kRGB4BitGray3, kRGB4BitGray3);
        SetRGBColor (dark, kRGB4BitGray3, kRGB4BitGray3, kRGB4BitGray3);
        this->TopLeftCorner (insetArea, light, dark, hilite);

        //    • TopRight 2
        SetRGBColor (light, kRGB4BitGray3, kRGB4BitGray3, kRGB4BitGray3);
        SetRGBColor (dark, kRGB4BitGray3, kRGB4BitGray3, kRGB4BitGray3);
        this->TopRightCorner (insetArea, light, dark, hilite);

        //    • BotLeft 3
        //    • Colors same as previous corner
        this->BotLeftCorner (insetArea, light, dark, hilite);

        //    • BotRight 4
        SetRGBColor (light, kRGB4BitGray1, kRGB4BitGray1, kRGB4BitGray1);
        SetRGBColor (dark, kRGB4BitGray1, kRGB4BitGray1, kRGB4BitGray1);
        this->BotRightCorner (insetArea, light, dark, hilite);

    }
    else //    • Draw the unhilited button
    {

        //    • Outside edge of bottom right shadow
        SetRGBColor (color, kRGB4BitGray3, kRGB4BitGray3, kRGB4BitGray3);
        SetIfColor (color);
        MoveTo (controlArea.left + 2, controlArea.bottom - 1);
        LineTo (controlArea.right - 3, controlArea.bottom - 1);
        MoveTo (controlArea.right - 1, controlArea.bottom - 3);
        LineTo (controlArea.right - 1, controlArea.top + 2);

        //    • Inset our rectangle as we move to the next level
        InsetRect (controlArea, 1, 1);

        //    • Light on edge of button - light source edge
        SetIfColor (gRGBWhite);
        MoveTo (controlArea.left, controlArea.bottom - 2);
        LineTo (controlArea.left, controlArea.top + 1);
        MoveTo (controlArea.left + 1, controlArea.top);
        LineTo (controlArea.right - 2, controlArea.top);

        //    • Inside edge of bottom right shadow
        SetRGBColor (color, kRGB4BitGray2, kRGB4BitGray2, kRGB4BitGray2);
        SetIfColor (color);
        MoveTo (controlArea.left + 1, controlArea.bottom - 1);
        LineTo (controlArea.right - 2, controlArea.bottom - 1);
        MoveTo (controlArea.right - 1, controlArea.bottom - 2);
        LineTo (controlArea.right - 1, controlArea.top + 1);

        //    •• Now draw the corners
        //    •    TopLeft 1
        this->TopLeftCorner (insetArea, gRGBWhite, gRGBWhite, hilite);

        //    • TopRight 2
        SetRGBColor (light, kRGB4BitGray2, kRGB4BitGray2, kRGB4BitGray2);
        this->TopRightCorner (insetArea, light, light, hilite);

        //    • BotLeft 3
        //    • Colors same as previous corner
        this->BotLeftCorner (insetArea, light, light, hilite);

        //    • BotRight 4
        SetRGBColor (light, kRGB4BitGray2, kRGB4BitGray2, kRGB4BitGray2);
        SetRGBColor (dark, kRGB4BitGray3, kRGB4BitGray3, kRGB4BitGray3);
        this->BotRightCorner (insetArea, light, dark, hilite);

    }


} // T3DTextButtonAdorner::Draw4Bit

//-------------------------------------------------------------------------------------
// T3DTextButtonAdorner::Draw1Bit
//    This routine is actually not called
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DTextButtonAdorner::Draw1Bit (    const CRect& /*rect */,
                                                        Boolean /*hilite*/)
{
//    We don't actually use this now

} // T3DTextButtonAdorner::Draw1Bit

//=====================================================================================
// •• BUTTON FRAME
//-------------------------------------------------------------------------------------
// T3DTextButtonAdorner::Frame
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DTextButtonAdorner::Frame (const CRect& rect)
{
    //    •    Draw the frame around the button this never changes
    FrameRoundRect (rect, kOvalWidth, kOvalHeight);

} // T3DTextButtonAdorner::Frame

//=====================================================================================
// •• CORNER DRAWING
//-------------------------------------------------------------------------------------
// T3DTextButtonAdorner::TopLeftCorner
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DTextButtonAdorner::TopLeftCorner (const CRect& rect,
                                                            const CRGBColor light,
                                                            const CRGBColor dark,
                                                            Boolean hilite )
{
    if (hilite)
    {
        //    • Set the outer corner pixel
        SetIfColor(dark);
        MoveTo(rect.left + 1, rect.top + 1);
        LineTo(rect.left + 1, rect.top + 1);

        //    • Set the inner corner pixel
        SetIfColor(light);
        MoveTo(rect.left + 2, rect.top + 2);
        LineTo(rect.left + 2, rect.top + 2);
    }
    else
    {
        //    • Set the outer corner pixel
        SetIfColor(light);
        MoveTo(rect.left + 1, rect.top + 1);
        LineTo(rect.left + 1, rect.top + 1);

        //    • Set the inner corner pixel
        SetIfColor(dark);
        MoveTo(rect.left + 2, rect.top + 2);
        LineTo(rect.left + 2, rect.top + 2);
    }

} // T3DTextButtonAdorner::TopLeftCorner

//-------------------------------------------------------------------------------------
// T3DTextButtonAdorner::TopRightCorner
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DTextButtonAdorner::TopRightCorner (    const CRect& rect,
                                                                const CRGBColor light,
                                                                const CRGBColor dark,
                                                                Boolean hilite )
{
    if (hilite)
    {
        //    • Set the outer corner pixel
        SetIfColor(dark);
        MoveTo(rect.right - 2, rect.top + 1);
        LineTo(rect.right - 2, rect.top + 1);

        //    • Set the inner corner pixel
        SetIfColor(light);
        MoveTo(rect.right - 3, rect.top + 2);
        LineTo(rect.right - 3, rect.top + 2);
    }
    else
    {
        //    • Set the outer corner pixel
        SetIfColor(light);
        MoveTo(rect.right - 2, rect.top + 1);
        LineTo(rect.right - 2, rect.top + 1);

        //    • Set the inner corner pixel
        SetIfColor(dark);
        MoveTo(rect.right - 3, rect.top + 2);
        LineTo(rect.right - 3, rect.top + 2);
    }

} // T3DTextButtonAdorner::TopRightCorner

//-------------------------------------------------------------------------------------
// T3DTextButtonAdorner::BotLeftCorner
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DTextButtonAdorner::BotLeftCorner (    const CRect& rect,
                                                                const CRGBColor light,
                                                                const CRGBColor dark,
                                                                Boolean hilite )
{
    if (hilite)
    {
        //    • Set the outer corner pixel
        SetIfColor(dark);
        MoveTo(rect.left + 1, rect.bottom - 2);
        LineTo(rect.left + 1, rect.bottom - 2);

        //    • Set the inner corner pixel
        SetIfColor(light);
        MoveTo(rect.left + 2, rect.bottom - 3);
        LineTo(rect.left + 2, rect.bottom - 3);
    }
    else
    {
        //    • Set the outer corner pixel
        SetIfColor(light);
        MoveTo(rect.left + 1, rect.bottom - 2);
        LineTo(rect.left + 1, rect.bottom - 2);

        //    • Set the inner corner pixel
        SetIfColor(dark);
        MoveTo(rect.left + 2, rect.bottom - 3);
        LineTo(rect.left + 2, rect.bottom - 3);
    }
} // T3DTextButtonAdorner::BotLeftCorner

//-------------------------------------------------------------------------------------
// T3DTextButtonAdorner::BotRightCorner
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DTextButtonAdorner::BotRightCorner (const CRect& rect,
                                                            const CRGBColor light,
                                                            const CRGBColor dark,
                                                            Boolean hilite)
{
    if (hilite)
    {
        //    • Set the outer corner pixel
        SetIfColor(light);
        MoveTo(rect.right - 2, rect.bottom - 2);
        LineTo(rect.right - 2, rect.bottom - 2);

        //    • Set the inner corner pixel
        SetIfColor(dark);
        MoveTo(rect.right - 3, rect.bottom - 3);
        LineTo(rect.right - 3, rect.bottom - 3);
    }
    else
    {
        //    • Set the outer corner pixel
        SetIfColor(dark);
        MoveTo(rect.right - 2, rect.bottom - 2);
        LineTo(rect.right - 2, rect.bottom - 2);

        //    • Set the inner corner pixel
        SetIfColor(light);
        MoveTo(rect.right - 3, rect.bottom - 3);
        LineTo(rect.right - 3, rect.bottom - 3);
    }

} // T3DTextButtonAdorner::BotRightCorner



//=====================================================================================
//    ••••••••••••••••• 3DIconButton class and auxiliary adorner ••••••••••••••••••••••••
//=====================================================================================

//=====================================================================================
// T3DIconAdorner
//        This is an auxiliary adorner for T3DIconButtons
//=====================================================================================

//-------------------------------------------------------------------------------------
// T3DIconAdorner::I3DIconAdorner
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DIconAdorner::I3DIconAdorner (    Boolean freeOnDeletion )
{
    //    • Call our superclass to complete initialization
    this->IAdorner ( k3DIconAdorner,freeOnDeletion );

} // T3DIconAdorner::I3DIconAdorner

//=====================================================================================
// •• DRAWING
//-------------------------------------------------------------------------------------
// T3DIconAdorner::Draw
//-------------------------------------------------------------------------------------
//
//    This overridden draw method handles the drawing of the buttons border and then
//    branches to the appropriate appropriate method to draw the buttons contents, based
//    on the bit depth of the device being drawn to.  Currently this method supports 1, 4,
//    and 8 bit or more devices.

#pragma segment A3DControlRes

pascal void T3DIconAdorner::Draw (     TView* itsView,
                                                const VRect& /*area*/ )
{

    VRect                theRect;
    CRect                qdArea;
    short                pixelSize;

    //    • Instantiate a stack based object that saves our graphic state
    CGraphicsState aGraphicsState;

    //    •    Coerce the view to a control and then get its QD area
    TControl* theControl = (TControl*)itsView;
    theControl->ControlArea ( theRect );
    theControl->ViewToQDRect ( theRect, qdArea );

    //    • Frame button with a black border that has a pixel missing in each corner
    //    this is drawn outside the while loop because it is always in black & white
    if (((TControl *)itsView)->IsDimmed())
        SetIfColor(kMediumGray);
    else
        SetIfColor ( gRGBBlack );
    this->Frame ( qdArea );

    //    • Inset the area in preparartion for the drawing of the buttons content
    InsetRect ( qdArea, 1, 1 );

    //    • Instantiate the stack based object that handles the per device clipping
    //    the area is passed in so that the object can do clipping from it
    if (((TControl *)itsView)->IsDimmed())
    {
//        Hack for non-CQD
        CDrawPerDevice device ( qdArea );
        while ( device.NextDevice ( pixelSize ) )
        {
            if ( pixelSize < 4 )
            {
//                Redraw the frame because it didn't draw if we're in non-CQD
                CRect tempArea = qdArea;
                CPenNormal();
                InsetRect(tempArea, -1, -1);
                this->Frame ( tempArea );
            }
        }
    }
    else
    {
        CDrawPerDevice device ( qdArea );

        //    • We will cycle through all of the devices, drawing will be handle based on
        //    the pixel size for each device
        while ( device.NextDevice ( pixelSize ) )
        {

            //    • Draw the button with full colors - there should really be two levels of
            //    drawing here, one for 4 bit color and one for 8 bit.
            if ( pixelSize >= 8 )
            {

                //    • Draw the button assuming 8 bit or better color
                this->Draw8Bit ( qdArea, theControl->fHilite );

            }
            else if ( pixelSize == 4 )    //    • Draw with only 16 colors
            {

                //    • For now we will draw the 1 bit style for 4 bit, but this should be
                //    replaced with a 4 bit algorithm which will give you 3 shades of gray
                this->Draw4Bit ( qdArea, theControl->fHilite );

            }
            else if ( pixelSize < 4 )    //    • Draw with 4 colors or less (no grays)
            {
                //    • Draw the 1 bit style for anything under 4 bit
                this->Draw1Bit ( qdArea, theControl->fHilite );

            }
        }
    }

} // T3DIconAdorner::Draw


//=====================================================================================
// •• PRIVATE DRAWING
//-------------------------------------------------------------------------------------
// T3DIconAdorner::Draw8Bit
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DIconAdorner::Draw8Bit ( const CRect& rect,
                                                    Boolean hilite )
{
    CRect             insetArea;
    CRect             controlArea;
    CRGBColor         color;
    CRGBColor         light;
    CRGBColor         dark;

    //    • Make a copy of the rect passed in
    controlArea = rect;

    //    • Save off the area passed in
    insetArea = rect;

    //    • Draw the hilited button
    if ( hilite )
    {

        //    • Outside edge of left top shadow
        SetRGBColor ( color, kRGB8BitGray9, kRGB8BitGray9, kRGB8BitGray9 );
        SetIfColor ( color );
        this->TopLeftSide ( controlArea );

        //    • Outside edge of bottom right shadow
        SetRGBColor ( color, kRGB8BitGray3, kRGB8BitGray3, kRGB8BitGray3 );
        SetIfColor ( color );
        this->BotRightSide ( controlArea );

        //    • Inset our rectangle as we move to the next level
        InsetRect ( controlArea, 1, 1 );

        //    • Inside edge of left top shadow
        SetRGBColor ( color, kRGB8BitGray8, kRGB8BitGray8, kRGB8BitGray8 );
        SetIfColor ( color );
        this->TopLeftSide ( controlArea );

        //    • Inside edge of bottom right shadow
        color = kMediumLightGray;
        SetIfColor ( color );
        this->BotRightSide ( controlArea );

        //    •• Now draw the corners
        //    •    TopLeft 1
        SetRGBColor ( light, kRGB8BitGray9, kRGB8BitGray9, kRGB8BitGray9 );
        SetRGBColor ( dark, kRGB8BitGray10, kRGB8BitGray10, kRGB8BitGray10 );
        this->TopLeftCorner ( insetArea, light, dark );

        //    • TopRight 2
        light = kMediumGray;
        SetRGBColor ( dark, kRGB8BitGray7, kRGB8BitGray7, kRGB8BitGray7 );
        this->TopRightCorner ( insetArea, light, dark );

        //    • BotLeft 3
        //    • Colors same as previous corner
        this->BotLeftCorner ( insetArea, light, dark );

        //    • BotRight 4
        light = kLightGray2;
        SetRGBColor ( dark, kRGB8BitGray3, kRGB8BitGray3, kRGB8BitGray3 );
        this->BotRightCorner ( insetArea, light, dark, hilite );

        //    • Setup fill color for buttons face - hilite
        color = kMediumGray;

    }
    else //    • Draw the unhilited button
    {
        //    • Outside edge of left top shadow
        color = kLightGray2;
        SetIfColor ( color );
        this->TopLeftSide ( controlArea );

        //    • Outside edge of bottom right shadow
        SetRGBColor ( color, kRGB8BitGray7, kRGB8BitGray7, kRGB8BitGray7 );
        SetIfColor ( color );
        this->BotRightSide ( controlArea );

        //    • Inset our rectangle as we move to the next level
        InsetRect ( controlArea, 1, 1 );

        //    • Light on edge of button - light source edge
        SetIfColor ( gRGBWhite );
        this->TopLeftSide ( controlArea );

        //    • Inside edge of bottom right shadow
        color = kMediumGray;
        SetIfColor ( color );
        this->BotRightSide ( controlArea );

        //    •• Now draw the corners
        //    •    TopLeft 1
        this->TopLeftCorner ( insetArea, gRGBWhite, gRGBWhite );

        //    • TopRight 2
        SetRGBColor ( light, kRGB8BitGray3, kRGB8BitGray3, kRGB8BitGray3 );
        this->TopRightCorner ( insetArea, light, light );

        //    • BotLeft 3
        //    • Colors same as previous corner
        this->BotLeftCorner ( insetArea, light, light );

        //    • BotRight 4
        SetRGBColor ( light, kRGB8BitGray8, kRGB8BitGray8, kRGB8BitGray8 );
        SetRGBColor ( dark, kRGB8BitGray9, kRGB8BitGray9, kRGB8BitGray9 );
        this->BotRightCorner ( insetArea, light, dark, hilite );

        //    • Setup fill color for button face
        color = kLightGray2;

    }

    //    • Inset our rectangle so that we can fill the rest of the area
    InsetRect ( controlArea, 1, 1 );

    //    • Now we will fill the rest of the button NOTE: color was setup at the
    //    end of either the hilite or normal draw routines
    SetIfColor ( color );
    PaintRect ( controlArea );

} // T3DIconAdorner::Draw8Bit


//-------------------------------------------------------------------------------------
// T3DIconAdorner::Draw4Bit
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DIconAdorner::Draw4Bit ( const CRect& rect,
                                                    Boolean hilite )
{
    CRect             insetArea;
    CRect             controlArea;
    CRGBColor         color;
    CRGBColor         light;
    CRGBColor         dark;

    //    • Make a copy of the rect passed in
    controlArea = rect;

    //    • Save off the area passed in
    insetArea = rect;

    //    • Draw the hilited button
    if ( hilite )
    {

        //    • Outside edge of left top shadow
        SetRGBColor ( color, kRGB4BitGray3, kRGB4BitGray3, kRGB4BitGray3 );
        SetIfColor ( color );
        this->TopLeftSide ( controlArea );

        //    • Outside edge of bottom right shadow
        SetRGBColor ( color, kRGB4BitGray1, kRGB4BitGray1, kRGB4BitGray1 );
        SetIfColor ( color );
        this->BotRightSide ( controlArea );

        //    • Inset our rectangle as we move to the next level
        InsetRect ( controlArea, 1, 1 );

        //    • Inside edge of left top shadow
        SetRGBColor ( color, kRGB4BitGray3, kRGB4BitGray3, kRGB4BitGray3 );
        SetIfColor ( color );
        this->TopLeftSide ( controlArea );

        //    • Inside edge of bottom right shadow
        SetRGBColor ( color, kRGB4BitGray1, kRGB4BitGray1, kRGB4BitGray1 );
        SetIfColor ( color );
        this->BotRightSide ( controlArea );

        //    •• Now draw the corners
        //    •    TopLeft 1
        SetRGBColor ( light, kRGB4BitGray3, kRGB4BitGray3, kRGB4BitGray3 );
        this->TopLeftCorner ( insetArea, light, light );

        //    • TopRight 2
        SetRGBColor ( light, kRGB4BitGray2, kRGB4BitGray2, kRGB4BitGray2 );
        this->TopRightCorner ( insetArea, light, light );

        //    • BotLeft 3
        SetRGBColor ( light, kRGB4BitGray2, kRGB4BitGray2, kRGB4BitGray2 );
        this->BotLeftCorner ( insetArea, light, light );

        //    • BotRight 4
        SetRGBColor ( light, kRGB4BitGray1, kRGB4BitGray1, kRGB4BitGray1 );
        this->BotRightCorner ( insetArea, light, light, hilite );

        //    • Setup fill color for button face - hilite
        SetRGBColor ( color, kRGB4BitGray2, kRGB4BitGray2, kRGB4BitGray2 );

    }
    else //    • Draw the unhilited button
    {
        //    • Outside edge of left top shadow
        SetRGBColor ( color, kRGB4BitGray1, kRGB4BitGray1, kRGB4BitGray1 );
        SetIfColor ( color );
        this->TopLeftSide ( controlArea );

        //    • Outside edge of bottom right shadow
        SetRGBColor ( color, kRGB4BitGray2, kRGB4BitGray2, kRGB4BitGray2 );
        SetIfColor ( color );
        this->BotRightSide ( controlArea );

        //    • Inset our rectangle as we move to the next level
        InsetRect ( controlArea, 1, 1 );

        //    • Light on edge of button - light source edge
        SetIfColor ( gRGBWhite );
        this->TopLeftSide ( controlArea );

        //    • Inside edge of bottom right shadow
        SetRGBColor ( color, kRGB4BitGray2, kRGB4BitGray2, kRGB4BitGray2 );
        SetIfColor ( color );
        this->BotRightSide ( controlArea );

        //    •• Now draw the corners
        //    •    TopLeft 1
        this->TopLeftCorner ( insetArea, gRGBWhite, gRGBWhite );

        //    • TopRight 2
        SetRGBColor ( light, kRGB4BitGray1, kRGB4BitGray1, kRGB4BitGray1 );
        this->TopRightCorner ( insetArea, light, light );

        //    • BotLeft 3
        //    • Colors same as previous corner
        this->BotLeftCorner ( insetArea, light, light );

        //    • BotRight 4
        SetRGBColor ( light, kRGB4BitGray3, kRGB4BitGray3, kRGB4BitGray3 );
        this->BotRightCorner ( insetArea, light, light, hilite );

        //    • Setup fill color for button face
        SetRGBColor ( color, kRGB4BitGray1, kRGB4BitGray1, kRGB4BitGray1 );

    }

    //    • Inset our rectangle so that we can fill the rest of the area
    InsetRect ( controlArea, 1, 1 );

    //    • Now we will fill the rest of the button NOTE: color was setup at the
    //    end of either the hilite or normal draw routines
    SetIfColor ( color );
    PaintRect ( controlArea );

} // T3DIconAdorner::Draw4Bit

//-------------------------------------------------------------------------------------
// T3DIconAdorner::Draw1Bit
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DIconAdorner::Draw1Bit ( const CRect& rect,
                                                    Boolean hilite )
{
    CRect insetArea;
    CRect controlArea;

    CPenNormal();

    //    • Make a copy of the rect passed in
    controlArea = rect;

    //    • Save off the area passed in
    insetArea = controlArea;

    //    • First we paint the inside white
    PenPat(&qd.white);
    ForeColor ( whiteColor );
    PaintRect ( controlArea );

    //    • Outside edge of bottom right shadow
    PenPat ( &qd.gray );
    ForeColor ( blackColor );
    this->BotRightSide ( controlArea );

    //    • Inset the rectangle again for the next level
    InsetRect ( controlArea, 1, 1 );

    //    • Inside edge of bottom right shadow
    this->BotRightSide ( controlArea );

    //    • We are hiliting so we need to invert the whole thing
    if  ( hilite )
        InvertRect ( insetArea );

} // T3DIconAdorner::Draw1Bit


//=====================================================================================
// •• BUTTON FRAME
//-------------------------------------------------------------------------------------
// T3DIconAdorner::Frame
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DIconAdorner::Frame ( const CRect& rect )
{
    //    •    Draw the frame around the button this never changes
    MoveTo ( rect.left, rect.bottom - 2 );
    LineTo ( rect.left, rect.top + 1 );
    MoveTo ( rect.left + 1, rect.top );
    LineTo ( rect.right - 2, rect.top );
    MoveTo ( rect.left + 1, rect.bottom - 1 );
    LineTo ( rect.right - 2, rect.bottom - 1 );
    MoveTo ( rect.right - 1, rect.bottom - 2 );
    LineTo ( rect.right - 1, rect.top + 1 );

} // T3DIconAdorner::Frame

//=====================================================================================
// •• EDGE DRAWING
//-------------------------------------------------------------------------------------
// T3DIconAdorner::TopLeftSide
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DIconAdorner::TopLeftSide ( const CRect& rect )
{

    MoveTo ( rect.left,rect.bottom-2 );
    LineTo ( rect.left,rect.top );
    LineTo ( rect.right-2,rect.top );

} // T3DIconAdorner::TopLeftSide

//-------------------------------------------------------------------------------------
// T3DIconAdorner::BotRightSide
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DIconAdorner::BotRightSide ( const CRect& rect )
{

    MoveTo ( rect.left,rect.bottom-1 );
    LineTo ( rect.right-1,rect.bottom-1 );
    LineTo ( rect.right-1,rect.top );

} // T3DIconAdorner::BotRightSide


//=====================================================================================
// •• CORNER DRAWING
//-------------------------------------------------------------------------------------
// T3DIconAdorner::TopLeftCorner
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DIconAdorner::TopLeftCorner (     const CRect& rect,
                                                            const CRGBColor light,
                                                            const CRGBColor dark  )
{
    //    • Set the outer corner pixel
    SetIfColor(dark);
    MoveTo(rect.left, rect.top);
    LineTo(rect.left, rect.top);

    //    • Set the inner corner pixel
    SetIfColor(light);
    MoveTo(rect.left + 1, rect.top + 1);
    LineTo(rect.left + 1, rect.top + 1);

} // T3DIconAdorner::TopLeftCorner

//-------------------------------------------------------------------------------------
// T3DIconAdorner::TopRightCorner
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DIconAdorner::TopRightCorner ( const CRect& rect,
                                                            const CRGBColor light,
                                                            const CRGBColor dark  )
{
    //    • Set the outer corner pixel
    SetIfColor(light);
    MoveTo(rect.right - 1, rect.top);
    LineTo(rect.right - 1, rect.top);

    //    • Set the inner corner pixel
    SetIfColor(dark);
    MoveTo(rect.right - 2, rect.top + 1);
    LineTo(rect.right - 2, rect.top + 1);

} // T3DIconAdorner::TopRightCorner

//-------------------------------------------------------------------------------------
// T3DIconAdorner::BotLeftCorner
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DIconAdorner::BotLeftCorner (     const CRect& rect,
                                                            const CRGBColor light,
                                                            const CRGBColor dark  )
{
    //    • Set the outer corner pixel
    SetIfColor(light);
    MoveTo(rect.left, rect.bottom - 1);
    LineTo(rect.left, rect.bottom - 1);

    //    • Set the inner corner pixel
    SetIfColor(dark);
    MoveTo(rect.left + 1, rect.bottom - 2);
    LineTo(rect.left + 1, rect.bottom - 2);

} // T3DIconAdorner::BotLeftCorner

//-------------------------------------------------------------------------------------
// T3DIconAdorner::BotRightCorner
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DIconAdorner::BotRightCorner ( const CRect& rect,
                                                            const CRGBColor light,
                                                            const CRGBColor dark,
                                                            Boolean hilite )
{
    if ( hilite )
    {
        //    • Set the outer corner pixel
        SetIfColor(light);
        MoveTo(rect.right - 1, rect.bottom - 1);
        LineTo(rect.right - 1, rect.bottom - 1);

        //    • Set the inner corner pixel
        SetIfColor(dark);
        MoveTo(rect.right - 2, rect.bottom - 2);
        LineTo(rect.right - 2, rect.bottom - 2);
    }
    else
    {
        //    • Set the outer corner pixel
        SetIfColor(dark);
        MoveTo(rect.right - 1, rect.bottom - 1);
        LineTo(rect.right - 1, rect.bottom - 1);

        //    • Set the inner corner pixel
        SetIfColor(light);
        MoveTo(rect.right - 2, rect.bottom - 2);
        LineTo(rect.right - 2, rect.bottom - 2);
    }

} // T3DIconAdorner::BotRightCorner


//=====================================================================================
// CLASS:    TIconSuite
//        The T3DIconButton class is based from this one.  However, you can use this
//        class alone if you wish.  It will draw an icon suite and allow you to
//        apply standard masks to respond to events
//=====================================================================================

//=====================================================================================
// •• INITIALIZATION & DISPOSAL
//-------------------------------------------------------------------------------------
// TIconSuite::Initialize
//-------------------------------------------------------------------------------------
#pragma segment    A3DControlOpen

pascal void TIconSuite::Initialize ()    // OVERRIDE
{
    inherited::Initialize ();

    fIconSuiteRsrcID = kNoResource;
    fAlignment = atNone;
    fDataHandle = NULL;
    fSelectorValue  = svAllAvailableData;

}    // TIconSuite::Initialize

//-------------------------------------------------------------------------------------
// TIconSuite::IIconSuite
//-------------------------------------------------------------------------------------
#pragma segment    A3DControlOpen

pascal void TIconSuite::IIconSuite (    TView* itsSuperView,
                                                    const VPoint& itsLocation,
                                                    const VPoint& itsSize,
                                                    SizeDeterminer itsHSizeDet,
                                                    SizeDeterminer itsVSizeDet,
                                                    ResNumber itsRsrcID,
                                                    IconAlignmentType    alignment,
                                                    IconSelectorValue selectorValue)
{
    FailInfo fi;

    this->IControl ( itsSuperView, itsLocation, itsSize, itsHSizeDet, itsVSizeDet );

    // • Setup our fields
    fAlignment = alignment;
    fEventNumber = mIconSuiteHit;                // We will use the mIconSuiteHit constant

    // • Installs the icon suite
    this->SetIconSuiteRsrcID ( itsRsrcID,selectorValue,kDontRedraw );

    // • Default is to enable hit testing
    this->SetEnable ( TRUE );

}    // TIconSuite::IIconSuite


//-------------------------------------------------------------------------------------
// TIconSuite::DoPostCreate
//-------------------------------------------------------------------------------------
#pragma segment    A3DControlOpen

pascal void TIconSuite::DoPostCreate(TDocument *itsDocument)
{
    inherited::DoPostCreate(itsDocument);

    fEventNumber = mIconSuiteHit;                // We will use the mIconSuiteHit constant
    fAlignment = atNone;

    // • Installs the icon suite - use the fUserArea field of the View resource
    //        as the icon suite
    this->SetIconSuiteRsrcID((short) fUserArea,svAllAvailableData,kDontRedraw);

    // • Default is to enable hit testing
    this->SetEnable ( TRUE );
}


//-------------------------------------------------------------------------------------
// TIconSuite::Clone
//-------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal TObject* TIconSuite::Clone ()    // OVERRIDE
{
    TIconSuite* aClonedIconSuite;
    Handle itsRsrcHandle;


    // • First call inherited clone and coerce the result to our type
    aClonedIconSuite = ( TIconSuite* )( inherited::Clone ());

    // • Setup the cloned icon suite's fields
    aClonedIconSuite->fDataHandle = NULL;
    aClonedIconSuite->fAlignment = fAlignment;

    // • Now get a new copy of the resource handle and place it in the data field
    if ( fDataHandle )
    {
        // • Make the resource non-purgeable, so the Toolbox doesn't die
        GetIconSuite ( &itsRsrcHandle, fIconSuiteRsrcID, fSelectorValue );

        aClonedIconSuite->fDataHandle = itsRsrcHandle;

        // • Check to see if it is a NIL resource
        FailNILResource ( aClonedIconSuite->fDataHandle );

    }

    // • Return the cloned icon suite
    return aClonedIconSuite;

}    //    TIconSuite::Clone

//-------------------------------------------------------------------------------------
// TIconSuite::Free
//-------------------------------------------------------------------------------------
#pragma segment A3DControlClose

pascal void TIconSuite::Free ()    // OVERRIDE
{

    // • Get rid of the icon suite
    this->ReleaseIconSuite ();

    inherited::Free ();

}    // TIconSuite::Free


//-------------------------------------------------------------------------------------
// TIconSuite::ReleaseIconSuite
//-------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal void TIconSuite::ReleaseIconSuite ()
{
    // • Set the rsrc ID field to nothing
    fIconSuiteRsrcID = kNoResource;

    // • If there is a data handle then dispose of the icon suite
    if ( fDataHandle )
    {
        OSErr    anError;

        anError = DisposeIconSuite ( fDataHandle, TRUE );
        fDataHandle = NULL;
    }

}    // TIconSuite::ReleaseIconSuite


//=====================================================================================
// •• ACCESSORS
//-------------------------------------------------------------------------------------
// TIconSuite::GetIconRect
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void TIconSuite::GetIconRect ( VRect& theRect )
{

    this->ControlArea ( theRect );

}    // <- GetIconRect


//-------------------------------------------------------------------------------------
// TIconSuite::SetIconSuite
//-------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal void TIconSuite::SetIconSuite ( Handle theSuite, Boolean redraw )
{
    ResNumber     theID;
    ResType         theType;
    CStr255         name;

    // • Release the existing icon suite and set the data field to
    // the new icon suite
    this->ReleaseIconSuite();
    fDataHandle = theSuite;

    // • Get the rsrc ID from the icon suite's handle
    GetResInfo ( theSuite, theID, theType, name) ;
    if ( ResError() == noErr )
        fIconSuiteRsrcID = theID;

    // • Get everything redrawn so that the new icon can be displayed, if needed
    if ( redraw )
        this->ForceRedraw ();

}    // TIconSuite::SetIconSuite


//-------------------------------------------------------------------------------------
// TIconSuite::SetIconSuiteRsrcID
//-------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal void TIconSuite::SetIconSuiteRsrcID ( short itsRsrcID, IconSelectorValue selectorValue, Boolean redraw )
{
    FailInfo     fi;
    Handle         itsRsrcHandle;

    if ( itsRsrcID != kNoResource )
    {
        if (fi.Try())
        {
            // • Make the resource non-purgeable, so the Toolbox doesn't die
            GetIconSuite ( &itsRsrcHandle, itsRsrcID, fSelectorValue );

            // • Check to see if it is a NIL resource
            FailNILResource ( itsRsrcHandle );

            // • Release the existing icon suite
            this->ReleaseIconSuite();

            // • Place the resource handle in our data field
            fDataHandle = itsRsrcHandle;
            fIconSuiteRsrcID = itsRsrcID;
            fSelectorValue = selectorValue;

            // • Hey! everything worked fine, we're out of here!!
            fi.Success ();
        }
        else    // Recover
        {
            fi.ReSignal ();
        }

    // • Get everything redrawn so that the new icon can be displayed, if needed
        if ( redraw )
            this->ForceRedraw ();

    }

}    // TIconSuite::SetIconSuiteRsrcID


//-------------------------------------------------------------------------------------
// TIconSuite::SetAlignment
//-------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal void TIconSuite::SetAlignment ( IconAlignmentType newAlignment, Boolean redraw )
{
    // • Setup the field to the new alignment value
    fAlignment = newAlignment;

    // • Get everything redrawn so that the new icon can be displayed, if needed
    if ( redraw )
        this->ForceRedraw ();

}    // TIconSuite::SetAlignment


//=====================================================================================
// •• DRAWING
//-------------------------------------------------------------------------------------
// TIconSuite::Draw
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void TIconSuite::Draw ( const VRect& area )    // OVERRIDE
{
    // • Get the icon plotted with the "ttNone" transorm applied
    // this transform shows the icon in its normal state
    this->DoPlotIconSuite ( ttNone );

    inherited::Draw ( area );

}    // <- Draw


//-------------------------------------------------------------------------------------
// TIconSuite::DoPlotIconSuite    PRIVATE
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void TIconSuite::DoPlotIconSuite ( IconTransformType transform )        // OVERRIDE
{
    SignedByte oldState;
    VRect theRect;
    CRect theQDRect;

    // • We will only do something if we have a datahandle
    if ( fDataHandle )
    {
        // • If the data handle we have is a resource then make sure its loaded
        if ( IsAResource ( fDataHandle ))
            LoadResource ( fDataHandle );

        if ( *fDataHandle )                // If there's room for the icon…
        {
            PenNormal();                        // NECESSARY?

            // • Get a Quickdraw rectangle of the control's extent
            this->GetIconRect ( theRect );
            this->ViewToQDRect ( theRect, theQDRect );

            // • Save off the state of the data handle
            oldState = HGetState ( fDataHandle );
            HNoPurge ( fDataHandle );
            HLock ( fDataHandle );

            // • Get the icon plotted using the transform passed in as
            // well as the current alignment
            PlotIconSuite ( &theQDRect, fAlignment, transform, fDataHandle);

            // • Restore the dtata handle's state
            HSetState ( fDataHandle, oldState );
        }
    }

}    // TIconSuite::DoPlotIconSuite


//=====================================================================================
// •• STATE
//-------------------------------------------------------------------------------------
// TIconSuite::Dim
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void TIconSuite::Dim ()        // OVERRIDE
{

    // • Plot the icon disabled if we are dimmed
    this->DoPlotIconSuite ( ttDisabled );

}    // TIconSuite::Dim


//-------------------------------------------------------------------------------------
// TIconSuite::Hilite
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void TIconSuite::Hilite ()    // OVERRIDE
{

    // • If the icon is hilited then plot it "selected" otherwise plot is as
    // normal in its unselected state
    if ( fHilite )
        this->DoPlotIconSuite ( ttSelected );
    else
        this->DoPlotIconSuite ( ttNone );

}    // TIconSuite::Hilite


//=====================================================================================
// CLASS:    T3DIconButton
//=====================================================================================

const    short    kDefaultSize    = 32;
//-------------------------------------------------------------------------------------
// T3DIconButton::Initialize
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DIconButton::Initialize ()                // Override
{

    inherited::Initialize ();

    f3DIconAdorner = NULL;
    fIconSize = kDefaultSize;        // Use 32x32 icons by default
    fMode = kButtonMode;            // Use button mode by default
    fState = FALSE;

} // T3DIconButton::Initialize

//-------------------------------------------------------------------------------------
// T3DIconButton::I3DButton
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void     T3DIconButton::I3DIconButton (    TView* itsSuperView,
                                                                        const VPoint& itsLocation,
                                                                        const VPoint& itsSize,
                                                                        SizeDeterminer itsHSizeDet,
                                                                        SizeDeterminer itsVSizeDet,
                                                                        short iconSize,
                                                                        ResNumber itsRsrcID,
                                                                        ButtonMode mode,
                                                                        Boolean state )
{

    IconSelectorValue selectorValue;

    switch ( iconSize )
    {
        case 12:
                selectorValue = svAllMiniData;
            break;
        case 16:
                selectorValue = svAllSmallData;
            break;
        case 32:
                selectorValue = svAllLargeData;
            break;
    }

    //    • Get our superclass setup
    this->IIconSuite ( itsSuperView, itsLocation, itsSize,
                                        itsHSizeDet, itsVSizeDet,
                                            itsRsrcID, atAbsoluteCenter, selectorValue );

    fIconSize  = iconSize;
    this->SetMode ( mode );
    fState = state;
    fEventNumber = mIconButtonHit;

    //    • Get the correct hiliteState setup
    if ( fState )
        this->HiliteState ( fState, kRedraw );

    //    • If we are being built procedurally then build the adorner
    if ( f3DIconAdorner == NULL )
        this->CreateButtonAdorner ();

} // T3DIconButton::I3DButton

//-------------------------------------------------------------------------------------
// T3DIconButton::DoPostCreate
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DIconButton::DoPostCreate ( TDocument *itsDocument ) // Override
{

    inherited::DoPostCreate ( itsDocument );

    fEventNumber = mIconButtonHit;

    if ( f3DIconAdorner == NULL )
        this->CreateButtonAdorner ();

} // T3DIconButton::DoPostCreate

//-------------------------------------------------------------------------------------
// T3DIconButton::CreateButtonAdorner
//-------------------------------------------------------------------------------------
#pragma segment A3DControlOpen

pascal void T3DIconButton::CreateButtonAdorner ()
{

    // •    Add the 3D Button Adorner
    T3DIconAdorner* adorner = new T3DIconAdorner;
    adorner->I3DIconAdorner ( kFreeOnDeletion );
    f3DIconAdorner = adorner;
    this->AddAdorner ( adorner, kAdornFirst, kDontInvalidate );

} // T3DIconButton::CreateButtonAdorner

//-------------------------------------------------------------------------------------
// T3DIconButton::GetIconRect
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DIconButton::GetIconRect ( VRect& theRect )
{

    this->ControlArea ( theRect );

    VCoordinate iconSize = this->GetIconSize ( theRect.GetSize () );

//    Center the icon
    theRect.top += ( theRect.bottom - theRect.top - iconSize ) / 2;
    theRect.bottom = theRect.top + iconSize;
    theRect.left += ( theRect.right - theRect.left - iconSize ) / 2;
    theRect.right = theRect.left + iconSize;

}    //    T3DIconButton::GetIconRect

//-------------------------------------------------------------------------------------
// T3DIconButton::GetIconSize
//-------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal short T3DIconButton::GetIconSize ( const VPoint& /*viewSize*/ )
{

    return fIconSize;

} // T3DIconButton::GetIconSize

//-------------------------------------------------------------------------------------
// T3DIconButton::Hilite
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DIconButton::Hilite ()        // Override
{

    VRect    area;
    this->GetExtent ( area) ;
    f3DIconAdorner->Draw ( this, area );

    inherited::Hilite ();

} // T3DIconButton::Hilite


//-------------------------------------------------------------------------------------
// T3DIconButton::Dim
//-------------------------------------------------------------------------------------
#pragma segment A3DControlRes

pascal void T3DIconButton::Dim ()        // Override
{
    inherited::Dim ();

} // T3DIconButton::Dim

//-------------------------------------------------------------------------------------
// T3DIconButton::SetIconSuite
//-------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal void T3DIconButton::SetIconSuite ( Handle theSuite,
                                                        Boolean redraw )
{

    inherited::SetIconSuite ( theSuite, redraw );

    this->SetAlignment ( atAbsoluteCenter, redraw );

} // T3DIconButton::SetIconSuite

//-------------------------------------------------------------------------------------
// T3DIconButton::SetIconSuiteRsrcID
//-------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal void T3DIconButton::SetIconSuiteRsrcID ( short itsRsrcID,
                                                                IconSelectorValue selectorValue,
                                                                Boolean redraw )
{

    inherited::SetIconSuiteRsrcID ( itsRsrcID, selectorValue, redraw );
    this->SetAlignment ( atAbsoluteCenter,redraw );

} // T3DIconButton::SetIconSuiteRsrcID

//-------------------------------------------------------------------------------------
// T3DIconButton::SetIconRsrcID
//-------------------------------------------------------------------------------------
#pragma segment A3DControlNonRes

pascal void T3DIconButton::SetIconRsrcID ( short itsRsrcID, Boolean redraw )
{

    VRect theRect;
    IconSelectorValue selectorValue;

    this->ControlArea ( theRect );
    switch ( this->GetIconSize ( theRect.GetSize () ) )
    {
        case 12:
                selectorValue = svAllMiniData;
            break;
        case 16:
                selectorValue = svAllSmallData;
            break;
        case 32:
                selectorValue = svAllLargeData;
            break;
    }

    this->SetIconSuiteRsrcID ( itsRsrcID, selectorValue, redraw );

} // T3DIconButton::SetIconRsrcID

//-------------------------------------------------------------------------------------
// T3DIconButton::SetMode
//-------------------------------------------------------------------------------------
#pragma    segment    A3DControlOpen

pascal void T3DIconButton::SetMode ( ButtonMode newMode )
{

    fMode = newMode;

}    // T3DIconButton::SetMode

//-------------------------------------------------------------------------------------
// T3DIconButton::GetMode
//-------------------------------------------------------------------------------------
#pragma    segment    A3DControlOpen

pascal ButtonMode T3DIconButton::GetMode ()
{

    return fMode;

}    // T3DIconButton::GetMode

//-------------------------------------------------------------------------------------
// T3DIconButton::IsSelected
//-------------------------------------------------------------------------------------
#pragma    segment    A3DControlNonRes

pascal Boolean T3DIconButton::IsSelected ( void )
{

    return fHilite;

}    // T3DIconButton::IsSelected

//-------------------------------------------------------------------------------------
// T3DIconButton::TrackMouse
//-------------------------------------------------------------------------------------
#pragma segment A3DControlSelCommand

pascal void T3DIconButton::TrackMouse (    TrackPhase aTrackPhase,
                                                             VPoint& ,
                                                             // anchorPoint
                                                             VPoint& ,
                                                             // previousPoint
                                                             VPoint& nextPoint,
                                                             Boolean )                            // OVERRIDE
{
    if (!this->IsDimmed())
        switch (aTrackPhase)
        {
            case trackBegin:
                fState = fHilite;
                this->HiliteState ( TRUE, kRedraw );
                break;
            case trackContinue:
                if (this->ContainsMouse ( nextPoint ))
                    this->HiliteState ( TRUE, kRedraw );
                else
                    this->HiliteState ( fState, kRedraw);
                break;
            case trackEnd:
                if (this->ContainsMouse ( nextPoint ))
                {
                    switch ( fMode )
                    {
                        case kButtonMode:
                            if ( fHilite )
                                this->HiliteState ( FALSE, kRedraw);
                            break;
                        case kSwitchMode:
                            this->HiliteState ( !fHilite, kRedraw);
                            break;
                        case kRadioMode:
                            if ( !fHilite )
                                this->HiliteState ( TRUE, kRedraw );
                            break;
                    }

                    this->HandleEvent ( fEventNumber, this, NULL );
                }
                break;
        }
}    // T3DIconButton::TrackMouse